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

orca_sdk/_generated_api_client/models/base_score_prediction_result.py

@@ -0,0 +1,108 @@
+"""
+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
+
+T = TypeVar("T", bound="BaseScorePredictionResult")
+
+
+@_attrs_define
+class BaseScorePredictionResult:
+    """Predicted score and confidence for a single input.
+
+    Attributes:
+        prediction_id (Union[None, str]):
+        confidence (float):
+        anomaly_score (Union[None, float]):
+        score (float):
+    """
+
+    prediction_id: Union[None, str]
+    confidence: float
+    anomaly_score: Union[None, float]
+    score: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prediction_id: Union[None, str]
+        prediction_id = self.prediction_id
+
+        confidence = self.confidence
+
+        anomaly_score: Union[None, float]
+        anomaly_score = self.anomaly_score
+
+        score = self.score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "prediction_id": prediction_id,
+                "confidence": confidence,
+                "anomaly_score": anomaly_score,
+                "score": score,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+
+        def _parse_prediction_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        prediction_id = _parse_prediction_id(d.pop("prediction_id"))
+
+        confidence = d.pop("confidence")
+
+        def _parse_anomaly_score(data: object) -> Union[None, float]:
+            if data is None:
+                return data
+            return cast(Union[None, float], data)
+
+        anomaly_score = _parse_anomaly_score(d.pop("anomaly_score"))
+
+        score = d.pop("score")
+
+        base_score_prediction_result = cls(
+            prediction_id=prediction_id,
+            confidence=confidence,
+            anomaly_score=anomaly_score,
+            score=score,
+        )
+
+        base_score_prediction_result.additional_properties = d
+        return base_score_prediction_result
+
+    @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/{evaluation_request.py → classification_evaluation_request.py}

@@ -17,48 +17,36 @@ from attrs import field as _attrs_field
 
 from ..types import UNSET, Unset
 
-T = TypeVar("T", bound="EvaluationRequest")
+T = TypeVar("T", bound="ClassificationEvaluationRequest")
 
 
 @_attrs_define
-class EvaluationRequest:
+class ClassificationEvaluationRequest:
     """
     Attributes:
+        datasource_id (str):
         datasource_label_column (str):
         datasource_value_column (str):
-        datasource_id (Union[None, Unset, str]):
-        datasource_name (Union[None, Unset, str]):
         memoryset_override_id (Union[None, Unset, str]):
         record_telemetry (Union[Unset, bool]):  Default: False.
         telemetry_tags (Union[List[str], None, Unset]):
     """
 
+    datasource_id: str
     datasource_label_column: str
     datasource_value_column: str
-    datasource_id: Union[None, Unset, str] = UNSET
-    datasource_name: Union[None, Unset, str] = UNSET
     memoryset_override_id: Union[None, Unset, str] = UNSET
     record_telemetry: Union[Unset, bool] = False
     telemetry_tags: Union[List[str], None, Unset] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        datasource_id = self.datasource_id
+
         datasource_label_column = self.datasource_label_column
 
         datasource_value_column = self.datasource_value_column
 
-        datasource_id: Union[None, Unset, str]
-        if isinstance(self.datasource_id, Unset):
-            datasource_id = UNSET
-        else:
-            datasource_id = self.datasource_id
-
-        datasource_name: Union[None, Unset, str]
-        if isinstance(self.datasource_name, Unset):
-            datasource_name = UNSET
-        else:
-            datasource_name = self.datasource_name
-
         memoryset_override_id: Union[None, Unset, str]
         if isinstance(self.memoryset_override_id, Unset):
             memoryset_override_id = UNSET
@@ -80,14 +68,11 @@ class EvaluationRequest:
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
+                "datasource_id": datasource_id,
                 "datasource_label_column": datasource_label_column,
                 "datasource_value_column": datasource_value_column,
             }
         )
-        if datasource_id is not UNSET:
-            field_dict["datasource_id"] = datasource_id
-        if datasource_name is not UNSET:
-            field_dict["datasource_name"] = datasource_name
         if memoryset_override_id is not UNSET:
             field_dict["memoryset_override_id"] = memoryset_override_id
         if record_telemetry is not UNSET:
@@ -100,28 +85,12 @@ class EvaluationRequest:
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         d = src_dict.copy()
+        datasource_id = d.pop("datasource_id")
+
         datasource_label_column = d.pop("datasource_label_column")
 
         datasource_value_column = d.pop("datasource_value_column")
 
-        def _parse_datasource_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)
-
-        datasource_id = _parse_datasource_id(d.pop("datasource_id", UNSET))
-
-        def _parse_datasource_name(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)
-
-        datasource_name = _parse_datasource_name(d.pop("datasource_name", UNSET))
-
         def _parse_memoryset_override_id(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -150,18 +119,17 @@ class EvaluationRequest:
 
         telemetry_tags = _parse_telemetry_tags(d.pop("telemetry_tags", UNSET))
 
-        evaluation_request = cls(
+        classification_evaluation_request = cls(
+            datasource_id=datasource_id,
             datasource_label_column=datasource_label_column,
             datasource_value_column=datasource_value_column,
-            datasource_id=datasource_id,
-            datasource_name=datasource_name,
             memoryset_override_id=memoryset_override_id,
             record_telemetry=record_telemetry,
             telemetry_tags=telemetry_tags,
         )
 
-        evaluation_request.additional_properties = d
-        return evaluation_request
+        classification_evaluation_request.additional_properties = d
+        return classification_evaluation_request
 
     @property
     def additional_keys(self) -> list[str]:

orca_sdk/_generated_api_client/models/{classification_evaluation_result.py → classification_metrics.py}

@@ -18,39 +18,43 @@ from attrs import field as _attrs_field
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.precision_recall_curve import PrecisionRecallCurve
+    from ..models.pr_curve import PRCurve
     from ..models.roc_curve import ROCCurve
 
 
-T = TypeVar("T", bound="ClassificationEvaluationResult")
+T = TypeVar("T", bound="ClassificationMetrics")
 
 
 @_attrs_define
-class ClassificationEvaluationResult:
+class ClassificationMetrics:
     """
     Attributes:
         f1_score (float):
         accuracy (float):
         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]):
+        roc_auc (Union[None, Unset, float]):
+        pr_auc (Union[None, Unset, float]):
+        pr_curve (Union['PRCurve', None, Unset]):
+        roc_curve (Union['ROCCurve', None, Unset]):
     """
 
     f1_score: float
     accuracy: float
     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
+    roc_auc: Union[None, Unset, float] = UNSET
+    pr_auc: Union[None, Unset, float] = UNSET
+    pr_curve: Union["PRCurve", None, Unset] = UNSET
+    roc_curve: Union["ROCCurve", None, Unset] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        from ..models.precision_recall_curve import PrecisionRecallCurve
+        from ..models.pr_curve import PRCurve
         from ..models.roc_curve import ROCCurve
 
         f1_score = self.f1_score
@@ -59,18 +63,6 @@ class ClassificationEvaluationResult:
 
         loss = self.loss
 
-        precision_recall_curve: Union[Dict[str, Any], None]
-        if isinstance(self.precision_recall_curve, PrecisionRecallCurve):
-            precision_recall_curve = self.precision_recall_curve.to_dict()
-        else:
-            precision_recall_curve = self.precision_recall_curve
-
-        roc_curve: Union[Dict[str, Any], None]
-        if isinstance(self.roc_curve, ROCCurve):
-            roc_curve = self.roc_curve.to_dict()
-        else:
-            roc_curve = self.roc_curve
-
         anomaly_score_mean: Union[None, Unset, float]
         if isinstance(self.anomaly_score_mean, Unset):
             anomaly_score_mean = UNSET
@@ -89,6 +81,34 @@ class ClassificationEvaluationResult:
         else:
             anomaly_score_variance = self.anomaly_score_variance
 
+        roc_auc: Union[None, Unset, float]
+        if isinstance(self.roc_auc, Unset):
+            roc_auc = UNSET
+        else:
+            roc_auc = self.roc_auc
+
+        pr_auc: Union[None, Unset, float]
+        if isinstance(self.pr_auc, Unset):
+            pr_auc = UNSET
+        else:
+            pr_auc = self.pr_auc
+
+        pr_curve: Union[Dict[str, Any], None, Unset]
+        if isinstance(self.pr_curve, Unset):
+            pr_curve = UNSET
+        elif isinstance(self.pr_curve, PRCurve):
+            pr_curve = self.pr_curve.to_dict()
+        else:
+            pr_curve = self.pr_curve
+
+        roc_curve: Union[Dict[str, Any], None, Unset]
+        if isinstance(self.roc_curve, Unset):
+            roc_curve = UNSET
+        elif isinstance(self.roc_curve, ROCCurve):
+            roc_curve = self.roc_curve.to_dict()
+        else:
+            roc_curve = self.roc_curve
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -96,8 +116,6 @@ class ClassificationEvaluationResult:
                 "f1_score": f1_score,
                 "accuracy": accuracy,
                 "loss": loss,
-                "precision_recall_curve": precision_recall_curve,
-                "roc_curve": roc_curve,
             }
         )
         if anomaly_score_mean is not UNSET:
@@ -106,12 +124,20 @@ class ClassificationEvaluationResult:
             field_dict["anomaly_score_median"] = anomaly_score_median
         if anomaly_score_variance is not UNSET:
             field_dict["anomaly_score_variance"] = anomaly_score_variance
+        if roc_auc is not UNSET:
+            field_dict["roc_auc"] = roc_auc
+        if pr_auc is not UNSET:
+            field_dict["pr_auc"] = pr_auc
+        if pr_curve is not UNSET:
+            field_dict["pr_curve"] = pr_curve
+        if roc_curve is not UNSET:
+            field_dict["roc_curve"] = roc_curve
 
         return field_dict
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
-        from ..models.precision_recall_curve import PrecisionRecallCurve
+        from ..models.pr_curve import PRCurve
         from ..models.roc_curve import ROCCurve
 
         d = src_dict.copy()
@@ -121,76 +147,100 @@ class ClassificationEvaluationResult:
 
         loss = d.pop("loss")
 
-        def _parse_precision_recall_curve(data: object) -> Union["PrecisionRecallCurve", None]:
+        def _parse_anomaly_score_mean(data: object) -> Union[None, Unset, float]:
             if data is None:
                 return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                precision_recall_curve_type_0 = PrecisionRecallCurve.from_dict(data)
-
-                return precision_recall_curve_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["PrecisionRecallCurve", None], data)
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
 
-        precision_recall_curve = _parse_precision_recall_curve(d.pop("precision_recall_curve"))
+        anomaly_score_mean = _parse_anomaly_score_mean(d.pop("anomaly_score_mean", UNSET))
 
-        def _parse_roc_curve(data: object) -> Union["ROCCurve", None]:
+        def _parse_anomaly_score_median(data: object) -> Union[None, Unset, float]:
             if data is None:
                 return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                roc_curve_type_0 = ROCCurve.from_dict(data)
-
-                return roc_curve_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["ROCCurve", None], data)
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
 
-        roc_curve = _parse_roc_curve(d.pop("roc_curve"))
+        anomaly_score_median = _parse_anomaly_score_median(d.pop("anomaly_score_median", UNSET))
 
-        def _parse_anomaly_score_mean(data: object) -> Union[None, Unset, float]:
+        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_mean = _parse_anomaly_score_mean(d.pop("anomaly_score_mean", UNSET))
+        anomaly_score_variance = _parse_anomaly_score_variance(d.pop("anomaly_score_variance", UNSET))
 
-        def _parse_anomaly_score_median(data: object) -> Union[None, Unset, float]:
+        def _parse_roc_auc(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))
+        roc_auc = _parse_roc_auc(d.pop("roc_auc", UNSET))
 
-        def _parse_anomaly_score_variance(data: object) -> Union[None, Unset, float]:
+        def _parse_pr_auc(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))
+        pr_auc = _parse_pr_auc(d.pop("pr_auc", UNSET))
+
+        def _parse_pr_curve(data: object) -> Union["PRCurve", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                pr_curve_type_0 = PRCurve.from_dict(data)
+
+                return pr_curve_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["PRCurve", None, Unset], data)
+
+        pr_curve = _parse_pr_curve(d.pop("pr_curve", UNSET))
 
-        classification_evaluation_result = cls(
+        def _parse_roc_curve(data: object) -> Union["ROCCurve", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                roc_curve_type_0 = ROCCurve.from_dict(data)
+
+                return roc_curve_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["ROCCurve", None, Unset], data)
+
+        roc_curve = _parse_roc_curve(d.pop("roc_curve", UNSET))
+
+        classification_metrics = 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,
+            roc_auc=roc_auc,
+            pr_auc=pr_auc,
+            pr_curve=pr_curve,
+            roc_curve=roc_curve,
         )
 
-        classification_evaluation_result.additional_properties = d
-        return classification_evaluation_result
+        classification_metrics.additional_properties = d
+        return classification_metrics
 
     @property
     def additional_keys(self) -> list[str]:

orca_sdk/_generated_api_client/models/{rac_model_metadata.py → classification_model_metadata.py}

@@ -20,11 +20,11 @@ from dateutil.parser import isoparse
 
 from ..models.rac_head_type import RACHeadType
 
-T = TypeVar("T", bound="RACModelMetadata")
+T = TypeVar("T", bound="ClassificationModelMetadata")
 
 
 @_attrs_define
-class RACModelMetadata:
+class ClassificationModelMetadata:
     """
     Attributes:
         id (str):
@@ -32,16 +32,17 @@ class RACModelMetadata:
         name (str):
         description (Union[None, str]):
         version (int):
-        num_classes (int):
-        head_type (RACHeadType):
         memoryset_id (str):
         memory_lookup_count (int):
-        weigh_memories (Union[None, bool]):
-        min_memory_weight (Union[None, float]):
         storage_path (str):
         memoryset_collection_name (str):
         created_at (datetime.datetime):
         updated_at (datetime.datetime):
+        locked (bool):
+        num_classes (int):
+        head_type (RACHeadType):
+        weigh_memories (Union[None, bool]):
+        min_memory_weight (Union[None, float]):
     """
 
     id: str
@@ -49,16 +50,17 @@ class RACModelMetadata:
     name: str
     description: Union[None, str]
     version: int
-    num_classes: int
-    head_type: RACHeadType
     memoryset_id: str
     memory_lookup_count: int
-    weigh_memories: Union[None, bool]
-    min_memory_weight: Union[None, float]
     storage_path: str
     memoryset_collection_name: str
     created_at: datetime.datetime
     updated_at: datetime.datetime
+    locked: bool
+    num_classes: int
+    head_type: RACHeadType
+    weigh_memories: Union[None, bool]
+    min_memory_weight: Union[None, float]
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -73,20 +75,10 @@ class RACModelMetadata:
 
         version = self.version
 
-        num_classes = self.num_classes
-
-        head_type = self.head_type.value if isinstance(self.head_type, Enum) else self.head_type
-
         memoryset_id = self.memoryset_id
 
         memory_lookup_count = self.memory_lookup_count
 
-        weigh_memories: Union[None, bool]
-        weigh_memories = self.weigh_memories
-
-        min_memory_weight: Union[None, float]
-        min_memory_weight = self.min_memory_weight
-
         storage_path = self.storage_path
 
         memoryset_collection_name = self.memoryset_collection_name
@@ -95,6 +87,18 @@ class RACModelMetadata:
 
         updated_at = self.updated_at.isoformat()
 
+        locked = self.locked
+
+        num_classes = self.num_classes
+
+        head_type = self.head_type.value if isinstance(self.head_type, Enum) else self.head_type
+
+        weigh_memories: Union[None, bool]
+        weigh_memories = self.weigh_memories
+
+        min_memory_weight: Union[None, float]
+        min_memory_weight = self.min_memory_weight
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -104,16 +108,17 @@ class RACModelMetadata:
                 "name": name,
                 "description": description,
                 "version": version,
-                "num_classes": num_classes,
-                "head_type": head_type,
                 "memoryset_id": memoryset_id,
                 "memory_lookup_count": memory_lookup_count,
-                "weigh_memories": weigh_memories,
-                "min_memory_weight": min_memory_weight,
                 "storage_path": storage_path,
                 "memoryset_collection_name": memoryset_collection_name,
                 "created_at": created_at,
                 "updated_at": updated_at,
+                "locked": locked,
+                "num_classes": num_classes,
+                "head_type": head_type,
+                "weigh_memories": weigh_memories,
+                "min_memory_weight": min_memory_weight,
             }
         )
 
@@ -137,14 +142,24 @@ class RACModelMetadata:
 
         version = d.pop("version")
 
-        num_classes = d.pop("num_classes")
-
-        head_type = RACHeadType(d.pop("head_type"))
-
         memoryset_id = d.pop("memoryset_id")
 
         memory_lookup_count = d.pop("memory_lookup_count")
 
+        storage_path = d.pop("storage_path")
+
+        memoryset_collection_name = d.pop("memoryset_collection_name")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+        locked = d.pop("locked")
+
+        num_classes = d.pop("num_classes")
+
+        head_type = RACHeadType(d.pop("head_type"))
+
         def _parse_weigh_memories(data: object) -> Union[None, bool]:
             if data is None:
                 return data
@@ -159,34 +174,27 @@ class RACModelMetadata:
 
         min_memory_weight = _parse_min_memory_weight(d.pop("min_memory_weight"))
 
-        storage_path = d.pop("storage_path")
-
-        memoryset_collection_name = d.pop("memoryset_collection_name")
-
-        created_at = isoparse(d.pop("created_at"))
-
-        updated_at = isoparse(d.pop("updated_at"))
-
-        rac_model_metadata = cls(
+        classification_model_metadata = cls(
             id=id,
             org_id=org_id,
             name=name,
             description=description,
             version=version,
-            num_classes=num_classes,
-            head_type=head_type,
             memoryset_id=memoryset_id,
             memory_lookup_count=memory_lookup_count,
-            weigh_memories=weigh_memories,
-            min_memory_weight=min_memory_weight,
             storage_path=storage_path,
             memoryset_collection_name=memoryset_collection_name,
             created_at=created_at,
             updated_at=updated_at,
+            locked=locked,
+            num_classes=num_classes,
+            head_type=head_type,
+            weigh_memories=weigh_memories,
+            min_memory_weight=min_memory_weight,
         )
 
-        rac_model_metadata.additional_properties = d
-        return rac_model_metadata
+        classification_model_metadata.additional_properties = d
+        return classification_model_metadata
 
     @property
     def additional_keys(self) -> list[str]: