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

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]:

orca_sdk/_generated_api_client/models/{prediction_request.py → classification_prediction_request.py}

@@ -10,22 +10,27 @@ The main change is:
 
 # flake8: noqa: C901
 
-from typing import Any, List, Type, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, 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="PredictionRequest")
+if TYPE_CHECKING:
+    from ..models.filter_item import FilterItem
+
+
+T = TypeVar("T", bound="ClassificationPredictionRequest")
 
 
 @_attrs_define
-class PredictionRequest:
+class ClassificationPredictionRequest:
     """
     Attributes:
         input_values (List[str]):
         expected_labels (Union[List[int], None, Unset]):
+        filters (Union[Unset, List['FilterItem']]):
         tags (Union[Unset, List[str]]):
         memoryset_override_id (Union[None, Unset, str]):
         save_telemetry (Union[Unset, bool]):  Default: True.
@@ -34,6 +39,7 @@ class PredictionRequest:
 
     input_values: List[str]
     expected_labels: Union[List[int], None, Unset] = UNSET
+    filters: Union[Unset, List["FilterItem"]] = UNSET
     tags: Union[Unset, List[str]] = UNSET
     memoryset_override_id: Union[None, Unset, str] = UNSET
     save_telemetry: Union[Unset, bool] = True
@@ -54,6 +60,13 @@ class PredictionRequest:
         else:
             expected_labels = self.expected_labels
 
+        filters: Union[Unset, List[Dict[str, Any]]] = UNSET
+        if not isinstance(self.filters, Unset):
+            filters = []
+            for filters_item_data in self.filters:
+                filters_item = filters_item_data.to_dict()
+                filters.append(filters_item)
+
         tags: Union[Unset, List[str]] = UNSET
         if not isinstance(self.tags, Unset):
             tags = self.tags
@@ -77,6 +90,8 @@ class PredictionRequest:
         )
         if expected_labels is not UNSET:
             field_dict["expected_labels"] = expected_labels
+        if filters is not UNSET:
+            field_dict["filters"] = filters
         if tags is not UNSET:
             field_dict["tags"] = tags
         if memoryset_override_id is not UNSET:
@@ -90,6 +105,8 @@ class PredictionRequest:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.filter_item import FilterItem
+
         d = src_dict.copy()
 
         def _parse_input_values(data: object) -> List[str]:
@@ -151,6 +168,13 @@ class PredictionRequest:
 
         expected_labels = _parse_expected_labels(d.pop("expected_labels", UNSET))
 
+        filters = []
+        _filters = d.pop("filters", UNSET)
+        for filters_item_data in _filters or []:
+            filters_item = FilterItem.from_dict(filters_item_data)
+
+            filters.append(filters_item)
+
         tags = cast(List[str], d.pop("tags", UNSET))
 
         def _parse_memoryset_override_id(data: object) -> Union[None, Unset, str]:
@@ -166,17 +190,18 @@ class PredictionRequest:
 
         save_telemetry_synchronously = d.pop("save_telemetry_synchronously", UNSET)
 
-        prediction_request = cls(
+        classification_prediction_request = cls(
             input_values=input_values,
             expected_labels=expected_labels,
+            filters=filters,
             tags=tags,
             memoryset_override_id=memoryset_override_id,
             save_telemetry=save_telemetry,
             save_telemetry_synchronously=save_telemetry_synchronously,
         )
 
-        prediction_request.additional_properties = d
-        return prediction_request
+        classification_prediction_request.additional_properties = d
+        return classification_prediction_request
 
     @property
     def additional_keys(self) -> list[str]: