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

orca_sdk/_generated_api_client/models/__init__.py

@@ -6,12 +6,15 @@ from .api_key_metadata_scope_item import ApiKeyMetadataScopeItem
 from .base_label_prediction_result import BaseLabelPredictionResult
 from .base_model import BaseModel
 from .body_create_datasource_datasource_post import BodyCreateDatasourceDatasourcePost
+from .cascade_edit_suggestions_request import CascadeEditSuggestionsRequest
+from .cascading_edit_suggestion import CascadingEditSuggestion
 from .classification_evaluation_result import ClassificationEvaluationResult
 from .clone_labeled_memoryset_request import CloneLabeledMemorysetRequest
 from .cluster_metrics import ClusterMetrics
 from .column_info import ColumnInfo
 from .column_type import ColumnType
 from .constraint_violation_error_response import ConstraintViolationErrorResponse
+from .count_predictions_request import CountPredictionsRequest
 from .create_api_key_request import CreateApiKeyRequest
 from .create_api_key_request_scope_item import CreateApiKeyRequestScopeItem
 from .create_api_key_response import CreateApiKeyResponse
@@ -39,6 +42,7 @@ from .finetune_embedding_model_request import FinetuneEmbeddingModelRequest
 from .finetune_embedding_model_request_training_args import FinetuneEmbeddingModelRequestTrainingArgs
 from .finetuned_embedding_model_metadata import FinetunedEmbeddingModelMetadata
 from .get_memories_request import GetMemoriesRequest
+from .http_validation_error import HTTPValidationError
 from .internal_server_error_response import InternalServerErrorResponse
 from .label_class_metrics import LabelClassMetrics
 from .label_prediction_memory_lookup import LabelPredictionMemoryLookup
@@ -110,6 +114,7 @@ from .telemetry_sort_options_direction import TelemetrySortOptionsDirection
 from .unauthenticated_error_response import UnauthenticatedErrorResponse
 from .unauthorized_error_response import UnauthorizedErrorResponse
 from .update_prediction_request import UpdatePredictionRequest
+from .validation_error import ValidationError
 
 __all__ = (
     "AnalyzeNeighborLabelsResult",
@@ -118,12 +123,15 @@ __all__ = (
     "BaseLabelPredictionResult",
     "BaseModel",
     "BodyCreateDatasourceDatasourcePost",
+    "CascadeEditSuggestionsRequest",
+    "CascadingEditSuggestion",
     "ClassificationEvaluationResult",
     "CloneLabeledMemorysetRequest",
     "ClusterMetrics",
     "ColumnInfo",
     "ColumnType",
     "ConstraintViolationErrorResponse",
+    "CountPredictionsRequest",
     "CreateApiKeyRequest",
     "CreateApiKeyRequestScopeItem",
     "CreateApiKeyResponse",
@@ -151,6 +159,7 @@ __all__ = (
     "FinetuneEmbeddingModelRequest",
     "FinetuneEmbeddingModelRequestTrainingArgs",
     "GetMemoriesRequest",
+    "HTTPValidationError",
     "InternalServerErrorResponse",
     "LabelClassMetrics",
     "LabeledMemory",
@@ -222,4 +231,5 @@ __all__ = (
     "UnauthenticatedErrorResponse",
     "UnauthorizedErrorResponse",
     "UpdatePredictionRequest",
+    "ValidationError",
 )

orca_sdk/_generated_api_client/models/cascade_edit_suggestions_request.py

@@ -0,0 +1,154 @@
+"""
+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, 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="CascadeEditSuggestionsRequest")
+
+
+@_attrs_define
+class CascadeEditSuggestionsRequest:
+    """
+    Attributes:
+        old_label (int):
+        new_label (int):
+        max_neighbors (Union[Unset, int]):  Default: 50.
+        max_validation_neighbors (Union[Unset, int]):  Default: 10.
+        similarity_threshold (Union[None, Unset, float]):
+        only_if_has_old_label (Union[Unset, bool]):  Default: True.
+        exclude_if_new_label (Union[Unset, bool]):  Default: True.
+        suggestion_cooldown_time (Union[Unset, float]):  Default: 86400.0.
+        label_confirmation_cooldown_time (Union[Unset, float]):  Default: 604800.0.
+    """
+
+    old_label: int
+    new_label: int
+    max_neighbors: Union[Unset, int] = 50
+    max_validation_neighbors: Union[Unset, int] = 10
+    similarity_threshold: Union[None, Unset, float] = UNSET
+    only_if_has_old_label: Union[Unset, bool] = True
+    exclude_if_new_label: Union[Unset, bool] = True
+    suggestion_cooldown_time: Union[Unset, float] = 86400.0
+    label_confirmation_cooldown_time: Union[Unset, float] = 604800.0
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        old_label = self.old_label
+
+        new_label = self.new_label
+
+        max_neighbors = self.max_neighbors
+
+        max_validation_neighbors = self.max_validation_neighbors
+
+        similarity_threshold: Union[None, Unset, float]
+        if isinstance(self.similarity_threshold, Unset):
+            similarity_threshold = UNSET
+        else:
+            similarity_threshold = self.similarity_threshold
+
+        only_if_has_old_label = self.only_if_has_old_label
+
+        exclude_if_new_label = self.exclude_if_new_label
+
+        suggestion_cooldown_time = self.suggestion_cooldown_time
+
+        label_confirmation_cooldown_time = self.label_confirmation_cooldown_time
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "old_label": old_label,
+                "new_label": new_label,
+            }
+        )
+        if max_neighbors is not UNSET:
+            field_dict["max_neighbors"] = max_neighbors
+        if max_validation_neighbors is not UNSET:
+            field_dict["max_validation_neighbors"] = max_validation_neighbors
+        if similarity_threshold is not UNSET:
+            field_dict["similarity_threshold"] = similarity_threshold
+        if only_if_has_old_label is not UNSET:
+            field_dict["only_if_has_old_label"] = only_if_has_old_label
+        if exclude_if_new_label is not UNSET:
+            field_dict["exclude_if_new_label"] = exclude_if_new_label
+        if suggestion_cooldown_time is not UNSET:
+            field_dict["suggestion_cooldown_time"] = suggestion_cooldown_time
+        if label_confirmation_cooldown_time is not UNSET:
+            field_dict["label_confirmation_cooldown_time"] = label_confirmation_cooldown_time
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        old_label = d.pop("old_label")
+
+        new_label = d.pop("new_label")
+
+        max_neighbors = d.pop("max_neighbors", UNSET)
+
+        max_validation_neighbors = d.pop("max_validation_neighbors", UNSET)
+
+        def _parse_similarity_threshold(data: object) -> Union[None, Unset, float]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        similarity_threshold = _parse_similarity_threshold(d.pop("similarity_threshold", UNSET))
+
+        only_if_has_old_label = d.pop("only_if_has_old_label", UNSET)
+
+        exclude_if_new_label = d.pop("exclude_if_new_label", UNSET)
+
+        suggestion_cooldown_time = d.pop("suggestion_cooldown_time", UNSET)
+
+        label_confirmation_cooldown_time = d.pop("label_confirmation_cooldown_time", UNSET)
+
+        cascade_edit_suggestions_request = cls(
+            old_label=old_label,
+            new_label=new_label,
+            max_neighbors=max_neighbors,
+            max_validation_neighbors=max_validation_neighbors,
+            similarity_threshold=similarity_threshold,
+            only_if_has_old_label=only_if_has_old_label,
+            exclude_if_new_label=exclude_if_new_label,
+            suggestion_cooldown_time=suggestion_cooldown_time,
+            label_confirmation_cooldown_time=label_confirmation_cooldown_time,
+        )
+
+        cascade_edit_suggestions_request.additional_properties = d
+        return cascade_edit_suggestions_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/cascading_edit_suggestion.py

@@ -0,0 +1,92 @@
+"""
+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, Type, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.labeled_memory_lookup import LabeledMemoryLookup
+
+
+T = TypeVar("T", bound="CascadingEditSuggestion")
+
+
+@_attrs_define
+class CascadingEditSuggestion:
+    """
+    Attributes:
+        neighbor (LabeledMemoryLookup): Single labeled memory lookup result.
+        suggested_label (int):
+        lookup_score (float):
+    """
+
+    neighbor: "LabeledMemoryLookup"
+    suggested_label: int
+    lookup_score: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        neighbor = self.neighbor.to_dict()
+
+        suggested_label = self.suggested_label
+
+        lookup_score = self.lookup_score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "neighbor": neighbor,
+                "suggested_label": suggested_label,
+                "lookup_score": lookup_score,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.labeled_memory_lookup import LabeledMemoryLookup
+
+        d = src_dict.copy()
+        neighbor = LabeledMemoryLookup.from_dict(d.pop("neighbor"))
+
+        suggested_label = d.pop("suggested_label")
+
+        lookup_score = d.pop("lookup_score")
+
+        cascading_edit_suggestion = cls(
+            neighbor=neighbor,
+            suggested_label=suggested_label,
+            lookup_score=lookup_score,
+        )
+
+        cascading_edit_suggestion.additional_properties = d
+        return cascading_edit_suggestion
+
+    @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/classification_evaluation_result.py

@@ -15,6 +15,8 @@ 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
+
 if TYPE_CHECKING:
     from ..models.precision_recall_curve import PrecisionRecallCurve
     from ..models.roc_curve import ROCCurve
@@ -32,6 +34,9 @@ class ClassificationEvaluationResult:
         loss (float):
         precision_recall_curve (Union['PrecisionRecallCurve', None]):
         roc_curve (Union['ROCCurve', None]):
+        anomaly_score_mean (Union[None, Unset, float]):
+        anomaly_score_median (Union[None, Unset, float]):
+        anomaly_score_variance (Union[None, Unset, float]):
     """
 
     f1_score: float
@@ -39,6 +44,9 @@ class ClassificationEvaluationResult:
     loss: float
     precision_recall_curve: Union["PrecisionRecallCurve", None]
     roc_curve: Union["ROCCurve", None]
+    anomaly_score_mean: Union[None, Unset, float] = UNSET
+    anomaly_score_median: Union[None, Unset, float] = UNSET
+    anomaly_score_variance: Union[None, Unset, float] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -63,6 +71,24 @@ class ClassificationEvaluationResult:
         else:
             roc_curve = self.roc_curve
 
+        anomaly_score_mean: Union[None, Unset, float]
+        if isinstance(self.anomaly_score_mean, Unset):
+            anomaly_score_mean = UNSET
+        else:
+            anomaly_score_mean = self.anomaly_score_mean
+
+        anomaly_score_median: Union[None, Unset, float]
+        if isinstance(self.anomaly_score_median, Unset):
+            anomaly_score_median = UNSET
+        else:
+            anomaly_score_median = self.anomaly_score_median
+
+        anomaly_score_variance: Union[None, Unset, float]
+        if isinstance(self.anomaly_score_variance, Unset):
+            anomaly_score_variance = UNSET
+        else:
+            anomaly_score_variance = self.anomaly_score_variance
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -74,6 +100,12 @@ class ClassificationEvaluationResult:
                 "roc_curve": roc_curve,
             }
         )
+        if anomaly_score_mean is not UNSET:
+            field_dict["anomaly_score_mean"] = anomaly_score_mean
+        if anomaly_score_median is not UNSET:
+            field_dict["anomaly_score_median"] = anomaly_score_median
+        if anomaly_score_variance is not UNSET:
+            field_dict["anomaly_score_variance"] = anomaly_score_variance
 
         return field_dict
 
@@ -119,12 +151,42 @@ class ClassificationEvaluationResult:
 
         roc_curve = _parse_roc_curve(d.pop("roc_curve"))
 
+        def _parse_anomaly_score_mean(data: object) -> Union[None, Unset, float]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        anomaly_score_mean = _parse_anomaly_score_mean(d.pop("anomaly_score_mean", UNSET))
+
+        def _parse_anomaly_score_median(data: object) -> Union[None, Unset, float]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        anomaly_score_median = _parse_anomaly_score_median(d.pop("anomaly_score_median", UNSET))
+
+        def _parse_anomaly_score_variance(data: object) -> Union[None, Unset, float]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        anomaly_score_variance = _parse_anomaly_score_variance(d.pop("anomaly_score_variance", UNSET))
+
         classification_evaluation_result = cls(
             f1_score=f1_score,
             accuracy=accuracy,
             loss=loss,
             precision_recall_curve=precision_recall_curve,
             roc_curve=roc_curve,
+            anomaly_score_mean=anomaly_score_mean,
+            anomaly_score_median=anomaly_score_median,
+            anomaly_score_variance=anomaly_score_variance,
         )
 
         classification_evaluation_result.additional_properties = d

orca_sdk/_generated_api_client/models/count_predictions_request.py

@@ -0,0 +1,195 @@
+"""
+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
+
+import datetime
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CountPredictionsRequest")
+
+
+@_attrs_define
+class CountPredictionsRequest:
+    """
+    Attributes:
+        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]):
+    """
+
+    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
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        model_id: Union[None, Unset, str]
+        if isinstance(self.model_id, Unset):
+            model_id = UNSET
+        else:
+            model_id = self.model_id
+
+        tag: Union[None, Unset, str]
+        if isinstance(self.tag, Unset):
+            tag = UNSET
+        else:
+            tag = self.tag
+
+        prediction_ids: Union[List[str], None, Unset]
+        if isinstance(self.prediction_ids, Unset):
+            prediction_ids = UNSET
+        elif isinstance(self.prediction_ids, list):
+            prediction_ids = self.prediction_ids
+
+        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
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if model_id is not UNSET:
+            field_dict["model_id"] = model_id
+        if tag is not UNSET:
+            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
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+
+        def _parse_model_id(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        model_id = _parse_model_id(d.pop("model_id", UNSET))
+
+        def _parse_tag(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        tag = _parse_tag(d.pop("tag", UNSET))
+
+        def _parse_prediction_ids(data: object) -> Union[List[str], None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                prediction_ids_type_0 = cast(List[str], data)
+
+                return prediction_ids_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[List[str], None, Unset], data)
+
+        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))
+
+        count_predictions_request = cls(
+            model_id=model_id,
+            tag=tag,
+            prediction_ids=prediction_ids,
+            start_timestamp=start_timestamp,
+            end_timestamp=end_timestamp,
+        )
+
+        count_predictions_request.additional_properties = d
+        return count_predictions_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/filter_item_field_type_0_item.py

@@ -3,6 +3,7 @@ from enum import Enum
 
 class FilterItemFieldType0Item(str, Enum):
     CREATED_AT = "created_at"
+    EDITED_AT = "edited_at"
     LABEL = "label"
     MEMORY_ID = "memory_id"
     METADATA = "metadata"