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

orca_sdk/_generated_api_client/models/{labeled_memoryset_metadata.py → memoryset_metadata.py}

@@ -18,18 +18,21 @@ from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 from dateutil.parser import isoparse
 
+from ..models.memory_type import MemoryType
+from ..models.memoryset_metadata_index_type import MemorysetMetadataIndexType
 from ..models.pretrained_embedding_model_name import PretrainedEmbeddingModelName
 from ..models.task_status import TaskStatus
 
 if TYPE_CHECKING:
+    from ..models.memoryset_metadata_index_params import MemorysetMetadataIndexParams
     from ..models.memoryset_metrics import MemorysetMetrics
 
 
-T = TypeVar("T", bound="LabeledMemorysetMetadata")
+T = TypeVar("T", bound="MemorysetMetadata")
 
 
 @_attrs_define
-class LabeledMemorysetMetadata:
+class MemorysetMetadata:
     """
     Attributes:
         id (str):
@@ -40,13 +43,17 @@ class LabeledMemorysetMetadata:
         length (int):
         pretrained_embedding_model_name (Union[None, PretrainedEmbeddingModelName]):
         finetuned_embedding_model_id (Union[None, str]):
-        label_names (List[str]):
         created_at (datetime.datetime):
         updated_at (datetime.datetime):
         memories_updated_at (datetime.datetime):
         insertion_task_id (str):
         insertion_status (TaskStatus): Status of task in the task queue
         metrics (MemorysetMetrics):
+        memory_type (MemoryType):
+        label_names (Union[List[str], None]):
+        index_type (MemorysetMetadataIndexType):
+        index_params (MemorysetMetadataIndexParams):
+        database_uri (Union[None, str]):
     """
 
     id: str
@@ -57,13 +64,17 @@ class LabeledMemorysetMetadata:
     length: int
     pretrained_embedding_model_name: Union[None, PretrainedEmbeddingModelName]
     finetuned_embedding_model_id: Union[None, str]
-    label_names: List[str]
     created_at: datetime.datetime
     updated_at: datetime.datetime
     memories_updated_at: datetime.datetime
     insertion_task_id: str
     insertion_status: TaskStatus
     metrics: "MemorysetMetrics"
+    memory_type: MemoryType
+    label_names: Union[List[str], None]
+    index_type: MemorysetMetadataIndexType
+    index_params: "MemorysetMetadataIndexParams"
+    database_uri: Union[None, str]
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -93,8 +104,6 @@ class LabeledMemorysetMetadata:
         finetuned_embedding_model_id: Union[None, str]
         finetuned_embedding_model_id = self.finetuned_embedding_model_id
 
-        label_names = self.label_names
-
         created_at = self.created_at.isoformat()
 
         updated_at = self.updated_at.isoformat()
@@ -109,6 +118,22 @@ class LabeledMemorysetMetadata:
 
         metrics = self.metrics.to_dict()
 
+        memory_type = self.memory_type.value if isinstance(self.memory_type, Enum) else self.memory_type
+
+        label_names: Union[List[str], None]
+        if isinstance(self.label_names, list):
+            label_names = self.label_names
+
+        else:
+            label_names = self.label_names
+
+        index_type = self.index_type.value if isinstance(self.index_type, Enum) else self.index_type
+
+        index_params = self.index_params.to_dict()
+
+        database_uri: Union[None, str]
+        database_uri = self.database_uri
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -121,13 +146,17 @@ class LabeledMemorysetMetadata:
                 "length": length,
                 "pretrained_embedding_model_name": pretrained_embedding_model_name,
                 "finetuned_embedding_model_id": finetuned_embedding_model_id,
-                "label_names": label_names,
                 "created_at": created_at,
                 "updated_at": updated_at,
                 "memories_updated_at": memories_updated_at,
                 "insertion_task_id": insertion_task_id,
                 "insertion_status": insertion_status,
                 "metrics": metrics,
+                "memory_type": memory_type,
+                "label_names": label_names,
+                "index_type": index_type,
+                "index_params": index_params,
+                "database_uri": database_uri,
             }
         )
 
@@ -135,6 +164,7 @@ class LabeledMemorysetMetadata:
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.memoryset_metadata_index_params import MemorysetMetadataIndexParams
         from ..models.memoryset_metrics import MemorysetMetrics
 
         d = src_dict.copy()
@@ -179,8 +209,6 @@ class LabeledMemorysetMetadata:
 
         finetuned_embedding_model_id = _parse_finetuned_embedding_model_id(d.pop("finetuned_embedding_model_id"))
 
-        label_names = cast(List[str], d.pop("label_names"))
-
         created_at = isoparse(d.pop("created_at"))
 
         updated_at = isoparse(d.pop("updated_at"))
@@ -193,7 +221,35 @@ class LabeledMemorysetMetadata:
 
         metrics = MemorysetMetrics.from_dict(d.pop("metrics"))
 
-        labeled_memoryset_metadata = cls(
+        memory_type = MemoryType(d.pop("memory_type"))
+
+        def _parse_label_names(data: object) -> Union[List[str], None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                label_names_type_0 = cast(List[str], data)
+
+                return label_names_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union[List[str], None], data)
+
+        label_names = _parse_label_names(d.pop("label_names"))
+
+        index_type = MemorysetMetadataIndexType(d.pop("index_type"))
+
+        index_params = MemorysetMetadataIndexParams.from_dict(d.pop("index_params"))
+
+        def _parse_database_uri(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        database_uri = _parse_database_uri(d.pop("database_uri"))
+
+        memoryset_metadata = cls(
             id=id,
             org_id=org_id,
             collection_name=collection_name,
@@ -202,17 +258,21 @@ class LabeledMemorysetMetadata:
             length=length,
             pretrained_embedding_model_name=pretrained_embedding_model_name,
             finetuned_embedding_model_id=finetuned_embedding_model_id,
-            label_names=label_names,
             created_at=created_at,
             updated_at=updated_at,
             memories_updated_at=memories_updated_at,
             insertion_task_id=insertion_task_id,
             insertion_status=insertion_status,
             metrics=metrics,
+            memory_type=memory_type,
+            label_names=label_names,
+            index_type=index_type,
+            index_params=index_params,
+            database_uri=database_uri,
         )
 
-        labeled_memoryset_metadata.additional_properties = d
-        return labeled_memoryset_metadata
+        memoryset_metadata.additional_properties = d
+        return memoryset_metadata
 
     @property
     def additional_keys(self) -> list[str]:

orca_sdk/_generated_api_client/models/memoryset_metadata_index_params.py

@@ -0,0 +1,55 @@
+"""
+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
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="MemorysetMetadataIndexParams")
+
+
+@_attrs_define
+class MemorysetMetadataIndexParams:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        memoryset_metadata_index_params = cls()
+
+        memoryset_metadata_index_params.additional_properties = d
+        return memoryset_metadata_index_params
+
+    @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/memoryset_metadata_index_type.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class MemorysetMetadataIndexType(str, Enum):
+    DISKANN = "DISKANN"
+    FLAT = "FLAT"
+    HNSW = "HNSW"
+    IVF_FLAT = "IVF_FLAT"
+    IVF_PQ = "IVF_PQ"
+    IVF_SQ8 = "IVF_SQ8"
+
+    def __str__(self) -> str:
+        return str(self.value)

orca_sdk/_generated_api_client/models/{labeled_memoryset_update.py → memoryset_update.py}

@@ -17,29 +17,26 @@ from attrs import field as _attrs_field
 
 from ..types import UNSET, Unset
 
-T = TypeVar("T", bound="LabeledMemorysetUpdate")
+T = TypeVar("T", bound="MemorysetUpdate")
 
 
 @_attrs_define
-class LabeledMemorysetUpdate:
+class MemorysetUpdate:
     """
     Attributes:
-        label_names (Union[List[str], None, Unset]):
+        label_names (Union[Unset, List[str]]):
         description (Union[None, Unset, str]):
+        name (Union[Unset, str]):
     """
 
-    label_names: Union[List[str], None, Unset] = UNSET
+    label_names: Union[Unset, List[str]] = UNSET
     description: Union[None, Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
-        label_names: Union[List[str], None, Unset]
-        if isinstance(self.label_names, Unset):
-            label_names = UNSET
-        elif isinstance(self.label_names, list):
-            label_names = self.label_names
-
-        else:
+        label_names: Union[Unset, List[str]] = UNSET
+        if not isinstance(self.label_names, Unset):
             label_names = self.label_names
 
         description: Union[None, Unset, str]
@@ -48,6 +45,8 @@ class LabeledMemorysetUpdate:
         else:
             description = self.description
 
+        name = self.name
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
@@ -55,29 +54,15 @@ class LabeledMemorysetUpdate:
             field_dict["label_names"] = label_names
         if description is not UNSET:
             field_dict["description"] = description
+        if name is not UNSET:
+            field_dict["name"] = name
 
         return field_dict
 
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         d = src_dict.copy()
-
-        def _parse_label_names(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()
-                label_names_type_0 = cast(List[str], data)
-
-                return label_names_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union[List[str], None, Unset], data)
-
-        label_names = _parse_label_names(d.pop("label_names", UNSET))
+        label_names = cast(List[str], d.pop("label_names", UNSET))
 
         def _parse_description(data: object) -> Union[None, Unset, str]:
             if data is None:
@@ -88,13 +73,16 @@ class LabeledMemorysetUpdate:
 
         description = _parse_description(d.pop("description", UNSET))
 
-        labeled_memoryset_update = cls(
+        name = d.pop("name", UNSET)
+
+        memoryset_update = cls(
             label_names=label_names,
             description=description,
+            name=name,
         )
 
-        labeled_memoryset_update.additional_properties = d
-        return labeled_memoryset_update
+        memoryset_update.additional_properties = d
+        return memoryset_update
 
     @property
     def additional_keys(self) -> list[str]:

orca_sdk/_generated_api_client/models/not_found_error_response_resource_type_0.py

@@ -15,6 +15,7 @@ class NotFoundErrorResponseResourceType0(str, Enum):
     ORG = "org"
     PREDICTION = "prediction"
     PRETRAINED_EMBEDDING_MODEL = "pretrained_embedding_model"
+    REGRESSION_MODEL = "regression_model"
     TASK = "task"
 
     def __str__(self) -> str:

orca_sdk/_generated_api_client/models/{paginated_labeled_memory_with_feedback_metrics.py → paginated_union_labeled_memory_with_feedback_metrics_scored_memory_with_feedback_metrics.py}

@@ -10,38 +10,46 @@ The main change is:
 
 # flake8: noqa: C901
 
-from typing import TYPE_CHECKING, Any, List, Type, TypeVar
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
 if TYPE_CHECKING:
     from ..models.labeled_memory_with_feedback_metrics import LabeledMemoryWithFeedbackMetrics
+    from ..models.scored_memory_with_feedback_metrics import ScoredMemoryWithFeedbackMetrics
 
 
-T = TypeVar("T", bound="PaginatedLabeledMemoryWithFeedbackMetrics")
+T = TypeVar("T", bound="PaginatedUnionLabeledMemoryWithFeedbackMetricsScoredMemoryWithFeedbackMetrics")
 
 
 @_attrs_define
-class PaginatedLabeledMemoryWithFeedbackMetrics:
+class PaginatedUnionLabeledMemoryWithFeedbackMetricsScoredMemoryWithFeedbackMetrics:
     """
     Attributes:
-        items (List['LabeledMemoryWithFeedbackMetrics']):
+        items (List[Union['LabeledMemoryWithFeedbackMetrics', 'ScoredMemoryWithFeedbackMetrics']]):
         total (int):
         offset (int):
         limit (int):
     """
 
-    items: List["LabeledMemoryWithFeedbackMetrics"]
+    items: List[Union["LabeledMemoryWithFeedbackMetrics", "ScoredMemoryWithFeedbackMetrics"]]
     total: int
     offset: int
     limit: int
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        from ..models.labeled_memory_with_feedback_metrics import LabeledMemoryWithFeedbackMetrics
+
         items = []
         for items_item_data in self.items:
-            items_item = items_item_data.to_dict()
+            items_item: Dict[str, Any]
+            if isinstance(items_item_data, LabeledMemoryWithFeedbackMetrics):
+                items_item = items_item_data.to_dict()
+            else:
+                items_item = items_item_data.to_dict()
+
             items.append(items_item)
 
         total = self.total
@@ -66,12 +74,31 @@ class PaginatedLabeledMemoryWithFeedbackMetrics:
     @classmethod
     def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
         from ..models.labeled_memory_with_feedback_metrics import LabeledMemoryWithFeedbackMetrics
+        from ..models.scored_memory_with_feedback_metrics import ScoredMemoryWithFeedbackMetrics
 
         d = src_dict.copy()
         items = []
         _items = d.pop("items")
         for items_item_data in _items:
-            items_item = LabeledMemoryWithFeedbackMetrics.from_dict(items_item_data)
+
+            def _parse_items_item(
+                data: object,
+            ) -> Union["LabeledMemoryWithFeedbackMetrics", "ScoredMemoryWithFeedbackMetrics"]:
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    items_item_type_0 = LabeledMemoryWithFeedbackMetrics.from_dict(data)
+
+                    return items_item_type_0
+                except:  # noqa: E722
+                    pass
+                if not isinstance(data, dict):
+                    raise TypeError()
+                items_item_type_1 = ScoredMemoryWithFeedbackMetrics.from_dict(data)
+
+                return items_item_type_1
+
+            items_item = _parse_items_item(items_item_data)
 
             items.append(items_item)
 
@@ -81,15 +108,15 @@ class PaginatedLabeledMemoryWithFeedbackMetrics:
 
         limit = d.pop("limit")
 
-        paginated_labeled_memory_with_feedback_metrics = cls(
+        paginated_union_labeled_memory_with_feedback_metrics_scored_memory_with_feedback_metrics = cls(
             items=items,
             total=total,
             offset=offset,
             limit=limit,
         )
 
-        paginated_labeled_memory_with_feedback_metrics.additional_properties = d
-        return paginated_labeled_memory_with_feedback_metrics
+        paginated_union_labeled_memory_with_feedback_metrics_scored_memory_with_feedback_metrics.additional_properties = d
+        return paginated_union_labeled_memory_with_feedback_metrics_scored_memory_with_feedback_metrics
 
     @property
     def additional_keys(self) -> list[str]:

orca_sdk/_generated_api_client/models/{precision_recall_curve.py → pr_curve.py}

@@ -15,23 +15,21 @@ from typing import Any, List, Type, TypeVar, cast
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-T = TypeVar("T", bound="PrecisionRecallCurve")
+T = TypeVar("T", bound="PRCurve")
 
 
 @_attrs_define
-class PrecisionRecallCurve:
+class PRCurve:
     """
     Attributes:
         thresholds (List[float]):
         precisions (List[float]):
         recalls (List[float]):
-        auc (float):
     """
 
     thresholds: List[float]
     precisions: List[float]
     recalls: List[float]
-    auc: float
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -41,8 +39,6 @@ class PrecisionRecallCurve:
 
         recalls = self.recalls
 
-        auc = self.auc
-
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -50,7 +46,6 @@ class PrecisionRecallCurve:
                 "thresholds": thresholds,
                 "precisions": precisions,
                 "recalls": recalls,
-                "auc": auc,
             }
         )
 
@@ -65,17 +60,14 @@ class PrecisionRecallCurve:
 
         recalls = cast(List[float], d.pop("recalls"))
 
-        auc = d.pop("auc")
-
-        precision_recall_curve = cls(
+        pr_curve = cls(
             thresholds=thresholds,
             precisions=precisions,
             recalls=recalls,
-            auc=auc,
         )
 
-        precision_recall_curve.additional_properties = d
-        return precision_recall_curve
+        pr_curve.additional_properties = d
+        return pr_curve
 
     @property
     def additional_keys(self) -> list[str]:

orca_sdk/_generated_api_client/models/{rac_model_update.py → predictive_model_update.py}

@@ -17,17 +17,19 @@ from attrs import field as _attrs_field
 
 from ..types import UNSET, Unset
 
-T = TypeVar("T", bound="RACModelUpdate")
+T = TypeVar("T", bound="PredictiveModelUpdate")
 
 
 @_attrs_define
-class RACModelUpdate:
+class PredictiveModelUpdate:
     """
     Attributes:
         description (Union[None, Unset, str]):
+        locked (Union[Unset, bool]):
     """
 
     description: Union[None, Unset, str] = UNSET
+    locked: Union[Unset, bool] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -37,11 +39,15 @@ class RACModelUpdate:
         else:
             description = self.description
 
+        locked = self.locked
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update({})
         if description is not UNSET:
             field_dict["description"] = description
+        if locked is not UNSET:
+            field_dict["locked"] = locked
 
         return field_dict
 
@@ -58,12 +64,15 @@ class RACModelUpdate:
 
         description = _parse_description(d.pop("description", UNSET))
 
-        rac_model_update = cls(
+        locked = d.pop("locked", UNSET)
+
+        predictive_model_update = cls(
             description=description,
+            locked=locked,
         )
 
-        rac_model_update.additional_properties = d
-        return rac_model_update
+        predictive_model_update.additional_properties = d
+        return predictive_model_update
 
     @property
     def additional_keys(self) -> list[str]:

orca_sdk/_generated_api_client/models/pretrained_embedding_model_metadata.py

@@ -11,12 +11,13 @@ The main change is:
 # flake8: noqa: C901
 
 from enum import Enum
-from typing import Any, Type, TypeVar
+from typing import Any, Type, TypeVar, Union
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
 from ..models.pretrained_embedding_model_name import PretrainedEmbeddingModelName
+from ..types import UNSET, Unset
 
 T = TypeVar("T", bound="PretrainedEmbeddingModelMetadata")
 
@@ -29,12 +30,14 @@ class PretrainedEmbeddingModelMetadata:
         max_seq_length (int):
         uses_context (bool):
         name (PretrainedEmbeddingModelName): Names of pretrained embedding models that are supported by OrcaCloud
+        experimental (Union[Unset, bool]):  Default: False.
     """
 
     embedding_dim: int
     max_seq_length: int
     uses_context: bool
     name: PretrainedEmbeddingModelName
+    experimental: Union[Unset, bool] = False
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -46,6 +49,8 @@ class PretrainedEmbeddingModelMetadata:
 
         name = self.name.value if isinstance(self.name, Enum) else self.name
 
+        experimental = self.experimental
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -56,6 +61,8 @@ class PretrainedEmbeddingModelMetadata:
                 "name": name,
             }
         )
+        if experimental is not UNSET:
+            field_dict["experimental"] = experimental
 
         return field_dict
 
@@ -70,11 +77,14 @@ class PretrainedEmbeddingModelMetadata:
 
         name = PretrainedEmbeddingModelName(d.pop("name"))
 
+        experimental = d.pop("experimental", UNSET)
+
         pretrained_embedding_model_metadata = cls(
             embedding_dim=embedding_dim,
             max_seq_length=max_seq_length,
             uses_context=uses_context,
             name=name,
+            experimental=experimental,
         )
 
         pretrained_embedding_model_metadata.additional_properties = d

orca_sdk/_generated_api_client/models/pretrained_embedding_model_name.py

@@ -2,11 +2,16 @@ from enum import Enum
 
 
 class PretrainedEmbeddingModelName(str, Enum):
+    BGE_BASE = "BGE_BASE"
     CDE_SMALL = "CDE_SMALL"
     CLIP_BASE = "CLIP_BASE"
     DISTILBERT = "DISTILBERT"
+    E5_LARGE = "E5_LARGE"
+    GIST_LARGE = "GIST_LARGE"
     GTE_BASE = "GTE_BASE"
     GTE_SMALL = "GTE_SMALL"
+    MXBAI_LARGE = "MXBAI_LARGE"
+    QWEN2_1_5B = "QWEN2_1_5B"
 
     def __str__(self) -> str:
         return str(self.value)

orca_sdk/_generated_api_client/models/rar_head_type.py

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