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

orca_sdk/_generated_api_client/models/embedding_model_result.py

@@ -32,12 +32,14 @@ class EmbeddingModelResult:
         embedding_model_path (str):
         analysis_result (AnalyzeNeighborLabelsResult):
         memoryset_name (Union[None, Unset, str]):
+        is_finetuned (Union[Unset, bool]):  Default: False.
     """
 
     embedding_model_name: str
     embedding_model_path: str
     analysis_result: "AnalyzeNeighborLabelsResult"
     memoryset_name: Union[None, Unset, str] = UNSET
+    is_finetuned: Union[Unset, bool] = False
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -53,6 +55,8 @@ class EmbeddingModelResult:
         else:
             memoryset_name = self.memoryset_name
 
+        is_finetuned = self.is_finetuned
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -64,6 +68,8 @@ class EmbeddingModelResult:
         )
         if memoryset_name is not UNSET:
             field_dict["memoryset_name"] = memoryset_name
+        if is_finetuned is not UNSET:
+            field_dict["is_finetuned"] = is_finetuned
 
         return field_dict
 
@@ -87,11 +93,14 @@ class EmbeddingModelResult:
 
         memoryset_name = _parse_memoryset_name(d.pop("memoryset_name", UNSET))
 
+        is_finetuned = d.pop("is_finetuned", UNSET)
+
         embedding_model_result = cls(
             embedding_model_name=embedding_model_name,
             embedding_model_path=embedding_model_path,
             analysis_result=analysis_result,
             memoryset_name=memoryset_name,
+            is_finetuned=is_finetuned,
         )
 
         embedding_model_result.additional_properties = d

orca_sdk/_generated_api_client/models/filter_item.py

@@ -12,13 +12,15 @@ The main change is:
 
 import datetime
 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 dateutil.parser import isoparse
 
 from ..models.filter_item_field_type_0_item import FilterItemFieldType0Item
+from ..models.filter_item_field_type_1_item_type_0 import FilterItemFieldType1ItemType0
+from ..models.filter_item_field_type_2_item_type_0 import FilterItemFieldType2ItemType0
 from ..models.filter_item_field_type_2_item_type_1 import FilterItemFieldType2ItemType1
 from ..models.filter_item_op import FilterItemOp
 
@@ -29,23 +31,23 @@ T = TypeVar("T", bound="FilterItem")
 class FilterItem:
     """
     Attributes:
-        field (Union[List[FilterItemFieldType0Item], List[Union[FilterItemFieldType2ItemType1, Literal['metrics']]],
-            List[Union[Literal['metadata'], str]]]):
+        field (Union[List[FilterItemFieldType0Item], List[Union[FilterItemFieldType1ItemType0, str]],
+            List[Union[FilterItemFieldType2ItemType0, FilterItemFieldType2ItemType1]]]):
         op (FilterItemOp):
         value (Union[List[bool], List[float], List[int], List[str], None, bool, datetime.datetime, float, int, str]):
     """
 
     field: Union[
         List[FilterItemFieldType0Item],
-        List[Union[FilterItemFieldType2ItemType1, Literal["metrics"]]],
-        List[Union[Literal["metadata"], str]],
+        List[Union[FilterItemFieldType1ItemType0, str]],
+        List[Union[FilterItemFieldType2ItemType0, FilterItemFieldType2ItemType1]],
     ]
     op: FilterItemOp
     value: Union[List[bool], List[float], List[int], List[str], None, bool, datetime.datetime, float, int, str]
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        field: Union[List[Union[Literal["metadata"], str]], List[Union[Literal["metrics"], str]], List[str]]
+        field: List[str]
         if isinstance(self.field, list):
             field = []
             for field_type_0_item_data in self.field:
@@ -85,8 +87,8 @@ class FilterItem:
             data: object,
         ) -> Union[
             List[FilterItemFieldType0Item],
-            List[Union[FilterItemFieldType2ItemType1, Literal["metrics"]]],
-            List[Union[Literal["metadata"], str]],
+            List[Union[FilterItemFieldType1ItemType0, str]],
+            List[Union[FilterItemFieldType2ItemType0, FilterItemFieldType2ItemType1]],
         ]:
             try:
                 if not isinstance(data, list):
@@ -108,14 +110,16 @@ class FilterItem:
                 _field_type_1 = data
                 for field_type_1_item_data in _field_type_1:
 
-                    def _parse_field_type_1_item(data: object) -> Union[Literal["metadata"], str]:
-                        field_type_1_item_type_0 = cast(Literal["metadata"], data)
-                        if field_type_1_item_type_0 != "metadata":
-                            raise ValueError(
-                                f"field_type_1_item_type_0 must match const 'metadata', got '{field_type_1_item_type_0}'"
-                            )
-                        return field_type_1_item_type_0
-                        return cast(Union[Literal["metadata"], str], data)
+                    def _parse_field_type_1_item(data: object) -> Union[FilterItemFieldType1ItemType0, str]:
+                        try:
+                            if not isinstance(data, str):
+                                raise TypeError()
+                            field_type_1_item_type_0 = FilterItemFieldType1ItemType0(data)
+
+                            return field_type_1_item_type_0
+                        except:  # noqa: E722
+                            pass
+                        return cast(Union[FilterItemFieldType1ItemType0, str], data)
 
                     field_type_1_item = _parse_field_type_1_item(field_type_1_item_data)
 
@@ -130,13 +134,17 @@ class FilterItem:
             _field_type_2 = data
             for field_type_2_item_data in _field_type_2:
 
-                def _parse_field_type_2_item(data: object) -> Union[FilterItemFieldType2ItemType1, Literal["metrics"]]:
-                    field_type_2_item_type_0 = cast(Literal["metrics"], data)
-                    if field_type_2_item_type_0 != "metrics":
-                        raise ValueError(
-                            f"field_type_2_item_type_0 must match const 'metrics', got '{field_type_2_item_type_0}'"
-                        )
-                    return field_type_2_item_type_0
+                def _parse_field_type_2_item(
+                    data: object,
+                ) -> Union[FilterItemFieldType2ItemType0, FilterItemFieldType2ItemType1]:
+                    try:
+                        if not isinstance(data, str):
+                            raise TypeError()
+                        field_type_2_item_type_0 = FilterItemFieldType2ItemType0(data)
+
+                        return field_type_2_item_type_0
+                    except:  # noqa: E722
+                        pass
                     if not isinstance(data, str):
                         raise TypeError()
                     field_type_2_item_type_1 = FilterItemFieldType2ItemType1(data)

orca_sdk/_generated_api_client/models/filter_item_field_type_1_item_type_0.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class FilterItemFieldType1ItemType0(str, Enum):
+    METADATA = "metadata"
+
+    def __str__(self) -> str:
+        return str(self.value)

orca_sdk/_generated_api_client/models/filter_item_field_type_2_item_type_0.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class FilterItemFieldType2ItemType0(str, Enum):
+    METRICS = "metrics"
+
+    def __str__(self) -> str:
+        return str(self.value)

orca_sdk/_generated_api_client/models/filter_item_field_type_2_item_type_1.py

@@ -15,6 +15,8 @@ class FilterItemFieldType2ItemType1(str, Enum):
     NEIGHBOR_PREDICTED_LABEL_MATCHES_CURRENT_LABEL = "neighbor_predicted_label_matches_current_label"
     NORMALIZED_NEIGHBOR_LABEL_ENTROPY = "normalized_neighbor_label_entropy"
     POTENTIAL_DUPLICATE_MEMORY_IDS = "potential_duplicate_memory_ids"
+    SPREAD = "spread"
+    UNIFORMITY = "uniformity"
 
     def __str__(self) -> str:
         return str(self.value)

orca_sdk/_generated_api_client/models/internal_server_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.internal_server_error_response_status_code import InternalServerErrorResponseStatusCode
+
 T = TypeVar("T", bound="InternalServerErrorResponse")
 
 
@@ -22,16 +25,16 @@ T = TypeVar("T", bound="InternalServerErrorResponse")
 class InternalServerErrorResponse:
     """
     Attributes:
-        status_code (Literal[500]):
+        status_code (InternalServerErrorResponseStatusCode):
         message (str):
     """
 
-    status_code: Literal[500]
+    status_code: InternalServerErrorResponseStatusCode
     message: 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
 
         message = self.message
 
@@ -49,9 +52,7 @@ class InternalServerErrorResponse:
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         d = src_dict.copy()
-        status_code = cast(Literal[500], d.pop("status_code"))
-        if status_code != 500:
-            raise ValueError(f"status_code must match const 500, got '{status_code}'")
+        status_code = InternalServerErrorResponseStatusCode(d.pop("status_code"))
 
         message = d.pop("message")
 

orca_sdk/_generated_api_client/models/internal_server_error_response_status_code.py

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

orca_sdk/_generated_api_client/models/labeled_memory.py

@@ -19,7 +19,7 @@ from dateutil.parser import isoparse
 
 if TYPE_CHECKING:
     from ..models.labeled_memory_metadata import LabeledMemoryMetadata
-    from ..models.labeled_memory_metrics import LabeledMemoryMetrics
+    from ..models.memory_metrics import MemoryMetrics
 
 
 T = TypeVar("T", bound="LabeledMemory")
@@ -39,7 +39,7 @@ class LabeledMemory:
         created_at (datetime.datetime):
         updated_at (datetime.datetime):
         edited_at (datetime.datetime):
-        metrics (LabeledMemoryMetrics): Metrics computed for a labeled memory.
+        metrics (MemoryMetrics):
         label (int):
         label_name (Union[None, str]):
     """
@@ -53,7 +53,7 @@ class LabeledMemory:
     created_at: datetime.datetime
     updated_at: datetime.datetime
     edited_at: datetime.datetime
-    metrics: "LabeledMemoryMetrics"
+    metrics: "MemoryMetrics"
     label: int
     label_name: Union[None, str]
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
@@ -110,7 +110,7 @@ class LabeledMemory:
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         from ..models.labeled_memory_metadata import LabeledMemoryMetadata
-        from ..models.labeled_memory_metrics import LabeledMemoryMetrics
+        from ..models.memory_metrics import MemoryMetrics
 
         d = src_dict.copy()
 
@@ -140,7 +140,7 @@ class LabeledMemory:
 
         edited_at = isoparse(d.pop("edited_at"))
 
-        metrics = LabeledMemoryMetrics.from_dict(d.pop("metrics"))
+        metrics = MemoryMetrics.from_dict(d.pop("metrics"))
 
         label = d.pop("label")
 

orca_sdk/_generated_api_client/models/labeled_memory_update.py

@@ -17,8 +17,8 @@ from attrs import define as _attrs_define
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
-    from ..models.labeled_memory_metrics import LabeledMemoryMetrics
     from ..models.labeled_memory_update_metadata_type_0 import LabeledMemoryUpdateMetadataType0
+    from ..models.memory_metrics import MemoryMetrics
 
 
 T = TypeVar("T", bound="LabeledMemoryUpdate")
@@ -33,20 +33,20 @@ class LabeledMemoryUpdate:
         value (Union[Unset, str]):
         metadata (Union['LabeledMemoryUpdateMetadataType0', None, Unset]):
         source_id (Union[None, Unset, str]):
+        metrics (Union['MemoryMetrics', None, Unset]):
         label (Union[Unset, int]):
-        metrics (Union['LabeledMemoryMetrics', None, Unset]):
     """
 
     memory_id: str
     value: Union[Unset, str] = UNSET
     metadata: Union["LabeledMemoryUpdateMetadataType0", None, Unset] = UNSET
     source_id: Union[None, Unset, str] = UNSET
+    metrics: Union["MemoryMetrics", None, Unset] = UNSET
     label: Union[Unset, int] = UNSET
-    metrics: Union["LabeledMemoryMetrics", None, Unset] = UNSET
 
     def to_dict(self) -> dict[str, Any]:
-        from ..models.labeled_memory_metrics import LabeledMemoryMetrics
         from ..models.labeled_memory_update_metadata_type_0 import LabeledMemoryUpdateMetadataType0
+        from ..models.memory_metrics import MemoryMetrics
 
         memory_id = self.memory_id
 
@@ -70,16 +70,16 @@ class LabeledMemoryUpdate:
         else:
             source_id = self.source_id
 
-        label = self.label
-
         metrics: Union[Dict[str, Any], None, Unset]
         if isinstance(self.metrics, Unset):
             metrics = UNSET
-        elif isinstance(self.metrics, LabeledMemoryMetrics):
+        elif isinstance(self.metrics, MemoryMetrics):
             metrics = self.metrics.to_dict()
         else:
             metrics = self.metrics
 
+        label = self.label
+
         field_dict: dict[str, Any] = {}
         field_dict.update(
             {
@@ -92,17 +92,17 @@ class LabeledMemoryUpdate:
             field_dict["metadata"] = metadata
         if source_id is not UNSET:
             field_dict["source_id"] = source_id
-        if label is not UNSET:
-            field_dict["label"] = label
         if metrics is not UNSET:
             field_dict["metrics"] = metrics
+        if label is not UNSET:
+            field_dict["label"] = label
 
         return field_dict
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
-        from ..models.labeled_memory_metrics import LabeledMemoryMetrics
         from ..models.labeled_memory_update_metadata_type_0 import LabeledMemoryUpdateMetadataType0
+        from ..models.memory_metrics import MemoryMetrics
 
         d = src_dict.copy()
         memory_id = d.pop("memory_id")
@@ -140,9 +140,7 @@ class LabeledMemoryUpdate:
 
         source_id = _parse_source_id(d.pop("source_id", UNSET))
 
-        label = d.pop("label", UNSET)
-
-        def _parse_metrics(data: object) -> Union["LabeledMemoryMetrics", None, Unset]:
+        def _parse_metrics(data: object) -> Union["MemoryMetrics", None, Unset]:
             if data is None:
                 return data
             if isinstance(data, Unset):
@@ -150,22 +148,24 @@ class LabeledMemoryUpdate:
             try:
                 if not isinstance(data, dict):
                     raise TypeError()
-                metrics_type_0 = LabeledMemoryMetrics.from_dict(data)
+                metrics_type_0 = MemoryMetrics.from_dict(data)
 
                 return metrics_type_0
             except:  # noqa: E722
                 pass
-            return cast(Union["LabeledMemoryMetrics", None, Unset], data)
+            return cast(Union["MemoryMetrics", None, Unset], data)
 
         metrics = _parse_metrics(d.pop("metrics", UNSET))
 
+        label = d.pop("label", UNSET)
+
         labeled_memory_update = cls(
             memory_id=memory_id,
             value=value,
             metadata=metadata,
             source_id=source_id,
-            label=label,
             metrics=metrics,
+            label=label,
         )
 
         return labeled_memory_update

orca_sdk/_generated_api_client/models/labeled_memory_with_feedback_metrics.py

@@ -18,11 +18,11 @@ from attrs import field as _attrs_field
 from dateutil.parser import isoparse
 
 if TYPE_CHECKING:
-    from ..models.labeled_memory_metrics import LabeledMemoryMetrics
     from ..models.labeled_memory_with_feedback_metrics_feedback_metrics import (
         LabeledMemoryWithFeedbackMetricsFeedbackMetrics,
     )
     from ..models.labeled_memory_with_feedback_metrics_metadata import LabeledMemoryWithFeedbackMetricsMetadata
+    from ..models.memory_metrics import MemoryMetrics
 
 
 T = TypeVar("T", bound="LabeledMemoryWithFeedbackMetrics")
@@ -41,7 +41,7 @@ class LabeledMemoryWithFeedbackMetrics:
         created_at (datetime.datetime):
         updated_at (datetime.datetime):
         edited_at (datetime.datetime):
-        metrics (LabeledMemoryMetrics): Metrics computed for a labeled memory.
+        metrics (MemoryMetrics):
         label (int):
         label_name (Union[None, str]):
         feedback_metrics (LabeledMemoryWithFeedbackMetricsFeedbackMetrics):
@@ -57,7 +57,7 @@ class LabeledMemoryWithFeedbackMetrics:
     created_at: datetime.datetime
     updated_at: datetime.datetime
     edited_at: datetime.datetime
-    metrics: "LabeledMemoryMetrics"
+    metrics: "MemoryMetrics"
     label: int
     label_name: Union[None, str]
     feedback_metrics: "LabeledMemoryWithFeedbackMetricsFeedbackMetrics"
@@ -121,11 +121,11 @@ class LabeledMemoryWithFeedbackMetrics:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
-        from ..models.labeled_memory_metrics import LabeledMemoryMetrics
         from ..models.labeled_memory_with_feedback_metrics_feedback_metrics import (
             LabeledMemoryWithFeedbackMetricsFeedbackMetrics,
         )
         from ..models.labeled_memory_with_feedback_metrics_metadata import LabeledMemoryWithFeedbackMetricsMetadata
+        from ..models.memory_metrics import MemoryMetrics
 
         d = src_dict.copy()
 
@@ -155,7 +155,7 @@ class LabeledMemoryWithFeedbackMetrics:
 
         edited_at = isoparse(d.pop("edited_at"))
 
-        metrics = LabeledMemoryMetrics.from_dict(d.pop("metrics"))
+        metrics = MemoryMetrics.from_dict(d.pop("metrics"))
 
         label = d.pop("label")
 

orca_sdk/_generated_api_client/models/lookup_request.py

@@ -26,10 +26,12 @@ class LookupRequest:
     Attributes:
         query (List[str]):
         count (Union[Unset, int]):  Default: 1.
+        prompt (Union[None, Unset, str]):
     """
 
     query: List[str]
     count: Union[Unset, int] = 1
+    prompt: Union[None, Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -37,6 +39,12 @@ class LookupRequest:
 
         count = self.count
 
+        prompt: Union[None, Unset, str]
+        if isinstance(self.prompt, Unset):
+            prompt = UNSET
+        else:
+            prompt = self.prompt
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -46,6 +54,8 @@ class LookupRequest:
         )
         if count is not UNSET:
             field_dict["count"] = count
+        if prompt is not UNSET:
+            field_dict["prompt"] = prompt
 
         return field_dict
 
@@ -56,9 +66,19 @@ class LookupRequest:
 
         count = d.pop("count", UNSET)
 
+        def _parse_prompt(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)
+
+        prompt = _parse_prompt(d.pop("prompt", UNSET))
+
         lookup_request = cls(
             query=query,
             count=count,
+            prompt=prompt,
         )
 
         lookup_request.additional_properties = d

orca_sdk/_generated_api_client/models/memory_metrics.py

@@ -31,6 +31,15 @@ class MemoryMetrics:
         cluster (Union[Unset, int]):
         embedding_2d (Union[Unset, List[float]]):
         anomaly_score (Union[Unset, float]):
+        neighbor_label_logits (Union[Unset, List[float]]):
+        neighbor_predicted_label (Union[Unset, int]):
+        neighbor_predicted_label_ambiguity (Union[Unset, float]):
+        neighbor_predicted_label_confidence (Union[Unset, float]):
+        current_label_neighbor_confidence (Union[Unset, float]):
+        normalized_neighbor_label_entropy (Union[Unset, float]):
+        neighbor_predicted_label_matches_current_label (Union[None, Unset, bool]):
+        spread (Union[Unset, float]):
+        uniformity (Union[Unset, float]):
     """
 
     is_duplicate: Union[Unset, bool] = UNSET
@@ -40,6 +49,15 @@ class MemoryMetrics:
     cluster: Union[Unset, int] = UNSET
     embedding_2d: Union[Unset, List[float]] = UNSET
     anomaly_score: Union[Unset, float] = UNSET
+    neighbor_label_logits: Union[Unset, List[float]] = UNSET
+    neighbor_predicted_label: Union[Unset, int] = UNSET
+    neighbor_predicted_label_ambiguity: Union[Unset, float] = UNSET
+    neighbor_predicted_label_confidence: Union[Unset, float] = UNSET
+    current_label_neighbor_confidence: Union[Unset, float] = UNSET
+    normalized_neighbor_label_entropy: Union[Unset, float] = UNSET
+    neighbor_predicted_label_matches_current_label: Union[None, Unset, bool] = UNSET
+    spread: Union[Unset, float] = UNSET
+    uniformity: Union[Unset, float] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -72,6 +90,30 @@ class MemoryMetrics:
 
         anomaly_score = self.anomaly_score
 
+        neighbor_label_logits: Union[Unset, List[float]] = UNSET
+        if not isinstance(self.neighbor_label_logits, Unset):
+            neighbor_label_logits = self.neighbor_label_logits
+
+        neighbor_predicted_label = self.neighbor_predicted_label
+
+        neighbor_predicted_label_ambiguity = self.neighbor_predicted_label_ambiguity
+
+        neighbor_predicted_label_confidence = self.neighbor_predicted_label_confidence
+
+        current_label_neighbor_confidence = self.current_label_neighbor_confidence
+
+        normalized_neighbor_label_entropy = self.normalized_neighbor_label_entropy
+
+        neighbor_predicted_label_matches_current_label: Union[None, Unset, bool]
+        if isinstance(self.neighbor_predicted_label_matches_current_label, Unset):
+            neighbor_predicted_label_matches_current_label = UNSET
+        else:
+            neighbor_predicted_label_matches_current_label = self.neighbor_predicted_label_matches_current_label
+
+        spread = self.spread
+
+        uniformity = self.uniformity
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
@@ -89,6 +131,26 @@ class MemoryMetrics:
             field_dict["embedding_2d"] = embedding_2d
         if anomaly_score is not UNSET:
             field_dict["anomaly_score"] = anomaly_score
+        if neighbor_label_logits is not UNSET:
+            field_dict["neighbor_label_logits"] = neighbor_label_logits
+        if neighbor_predicted_label is not UNSET:
+            field_dict["neighbor_predicted_label"] = neighbor_predicted_label
+        if neighbor_predicted_label_ambiguity is not UNSET:
+            field_dict["neighbor_predicted_label_ambiguity"] = neighbor_predicted_label_ambiguity
+        if neighbor_predicted_label_confidence is not UNSET:
+            field_dict["neighbor_predicted_label_confidence"] = neighbor_predicted_label_confidence
+        if current_label_neighbor_confidence is not UNSET:
+            field_dict["current_label_neighbor_confidence"] = current_label_neighbor_confidence
+        if normalized_neighbor_label_entropy is not UNSET:
+            field_dict["normalized_neighbor_label_entropy"] = normalized_neighbor_label_entropy
+        if neighbor_predicted_label_matches_current_label is not UNSET:
+            field_dict["neighbor_predicted_label_matches_current_label"] = (
+                neighbor_predicted_label_matches_current_label
+            )
+        if spread is not UNSET:
+            field_dict["spread"] = spread
+        if uniformity is not UNSET:
+            field_dict["uniformity"] = uniformity
 
         return field_dict
 
@@ -135,6 +197,33 @@ class MemoryMetrics:
 
         anomaly_score = d.pop("anomaly_score", UNSET)
 
+        neighbor_label_logits = cast(List[float], d.pop("neighbor_label_logits", UNSET))
+
+        neighbor_predicted_label = d.pop("neighbor_predicted_label", UNSET)
+
+        neighbor_predicted_label_ambiguity = d.pop("neighbor_predicted_label_ambiguity", UNSET)
+
+        neighbor_predicted_label_confidence = d.pop("neighbor_predicted_label_confidence", UNSET)
+
+        current_label_neighbor_confidence = d.pop("current_label_neighbor_confidence", UNSET)
+
+        normalized_neighbor_label_entropy = d.pop("normalized_neighbor_label_entropy", UNSET)
+
+        def _parse_neighbor_predicted_label_matches_current_label(data: object) -> Union[None, Unset, bool]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, bool], data)
+
+        neighbor_predicted_label_matches_current_label = _parse_neighbor_predicted_label_matches_current_label(
+            d.pop("neighbor_predicted_label_matches_current_label", UNSET)
+        )
+
+        spread = d.pop("spread", UNSET)
+
+        uniformity = d.pop("uniformity", UNSET)
+
         memory_metrics = cls(
             is_duplicate=is_duplicate,
             duplicate_memory_ids=duplicate_memory_ids,
@@ -143,6 +232,15 @@ class MemoryMetrics:
             cluster=cluster,
             embedding_2d=embedding_2d,
             anomaly_score=anomaly_score,
+            neighbor_label_logits=neighbor_label_logits,
+            neighbor_predicted_label=neighbor_predicted_label,
+            neighbor_predicted_label_ambiguity=neighbor_predicted_label_ambiguity,
+            neighbor_predicted_label_confidence=neighbor_predicted_label_confidence,
+            current_label_neighbor_confidence=current_label_neighbor_confidence,
+            normalized_neighbor_label_entropy=normalized_neighbor_label_entropy,
+            neighbor_predicted_label_matches_current_label=neighbor_predicted_label_matches_current_label,
+            spread=spread,
+            uniformity=uniformity,
         )
 
         memory_metrics.additional_properties = d