orca-sdk 0.1.0__py3-none-any.whl

orca_sdk/_generated_api_client/models/label_prediction_memory_lookup_metadata.py

@@ -0,0 +1,68 @@
+"""
+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="LabelPredictionMemoryLookupMetadata")
+
+
+@_attrs_define
+class LabelPredictionMemoryLookupMetadata:
+    """ """
+
+    additional_properties: dict[str, Union[None, bool, float, int, str]] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        label_prediction_memory_lookup_metadata = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+
+            def _parse_additional_property(data: object) -> Union[None, bool, float, int, str]:
+                if data is None:
+                    return data
+                return cast(Union[None, bool, float, int, str], data)
+
+            additional_property = _parse_additional_property(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        label_prediction_memory_lookup_metadata.additional_properties = additional_properties
+        return label_prediction_memory_lookup_metadata
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Union[None, bool, float, int, str]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Union[None, bool, float, int, str]) -> 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/label_prediction_result.py

@@ -0,0 +1,101 @@
+"""
+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="LabelPredictionResult")
+
+
+@_attrs_define
+class LabelPredictionResult:
+    """Predicted label and confidence for a single input.
+
+    Attributes:
+        prediction_id (str):
+        label (int):
+        label_name (Union[None, str]):
+        confidence (float):
+    """
+
+    prediction_id: str
+    label: int
+    label_name: Union[None, str]
+    confidence: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prediction_id = self.prediction_id
+
+        label = self.label
+
+        label_name: Union[None, str]
+        label_name = self.label_name
+
+        confidence = self.confidence
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "prediction_id": prediction_id,
+                "label": label,
+                "label_name": label_name,
+                "confidence": confidence,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        d = src_dict.copy()
+        prediction_id = d.pop("prediction_id")
+
+        label = d.pop("label")
+
+        def _parse_label_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        label_name = _parse_label_name(d.pop("label_name"))
+
+        confidence = d.pop("confidence")
+
+        label_prediction_result = cls(
+            prediction_id=prediction_id,
+            label=label,
+            label_name=label_name,
+            confidence=confidence,
+        )
+
+        label_prediction_result.additional_properties = d
+        return label_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/label_prediction_with_memories_and_feedback.py

@@ -0,0 +1,232 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+import datetime
+from typing import TYPE_CHECKING, 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
+
+if TYPE_CHECKING:
+    from ..models.label_prediction_memory_lookup import LabelPredictionMemoryLookup
+    from ..models.prediction_feedback import PredictionFeedback
+
+
+T = TypeVar("T", bound="LabelPredictionWithMemoriesAndFeedback")
+
+
+@_attrs_define
+class LabelPredictionWithMemoriesAndFeedback:
+    """
+    Attributes:
+        prediction_id (str):
+        label (int):
+        label_name (Union[None, str]):
+        confidence (float):
+        timestamp (datetime.datetime):
+        logits (List[float]):
+        input_value (str):
+        input_embedding (List[float]):
+        expected_label (Union[None, int]):
+        memories (List['LabelPredictionMemoryLookup']):
+        org_id (str):
+        memoryset_id (str):
+        model_id (str):
+        updated_at (datetime.datetime):
+        tags (List[str]):
+        feedbacks (List['PredictionFeedback']):
+    """
+
+    prediction_id: str
+    label: int
+    label_name: Union[None, str]
+    confidence: float
+    timestamp: datetime.datetime
+    logits: List[float]
+    input_value: str
+    input_embedding: List[float]
+    expected_label: Union[None, int]
+    memories: List["LabelPredictionMemoryLookup"]
+    org_id: str
+    memoryset_id: str
+    model_id: str
+    updated_at: datetime.datetime
+    tags: List[str]
+    feedbacks: List["PredictionFeedback"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        prediction_id = self.prediction_id
+
+        label = self.label
+
+        label_name: Union[None, str]
+        label_name = self.label_name
+
+        confidence = self.confidence
+
+        timestamp = self.timestamp.isoformat()
+
+        logits = self.logits
+
+        input_value: str
+        input_value = self.input_value
+
+        input_embedding = self.input_embedding
+
+        expected_label: Union[None, int]
+        expected_label = self.expected_label
+
+        memories = []
+        for memories_item_data in self.memories:
+            memories_item = memories_item_data.to_dict()
+            memories.append(memories_item)
+
+        org_id = self.org_id
+
+        memoryset_id = self.memoryset_id
+
+        model_id = self.model_id
+
+        updated_at = self.updated_at.isoformat()
+
+        tags = self.tags
+
+        feedbacks = []
+        for feedbacks_item_data in self.feedbacks:
+            feedbacks_item = feedbacks_item_data.to_dict()
+            feedbacks.append(feedbacks_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "prediction_id": prediction_id,
+                "label": label,
+                "label_name": label_name,
+                "confidence": confidence,
+                "timestamp": timestamp,
+                "logits": logits,
+                "input_value": input_value,
+                "input_embedding": input_embedding,
+                "expected_label": expected_label,
+                "memories": memories,
+                "org_id": org_id,
+                "memoryset_id": memoryset_id,
+                "model_id": model_id,
+                "updated_at": updated_at,
+                "tags": tags,
+                "feedbacks": feedbacks,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.label_prediction_memory_lookup import LabelPredictionMemoryLookup
+        from ..models.prediction_feedback import PredictionFeedback
+
+        d = src_dict.copy()
+        prediction_id = d.pop("prediction_id")
+
+        label = d.pop("label")
+
+        def _parse_label_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        label_name = _parse_label_name(d.pop("label_name"))
+
+        confidence = d.pop("confidence")
+
+        timestamp = isoparse(d.pop("timestamp"))
+
+        logits = cast(List[float], d.pop("logits"))
+
+        def _parse_input_value(data: object) -> str:
+            return cast(str, data)
+
+        input_value = _parse_input_value(d.pop("input_value"))
+
+        input_embedding = cast(List[float], d.pop("input_embedding"))
+
+        def _parse_expected_label(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        expected_label = _parse_expected_label(d.pop("expected_label"))
+
+        memories = []
+        _memories = d.pop("memories")
+        for memories_item_data in _memories:
+            memories_item = LabelPredictionMemoryLookup.from_dict(memories_item_data)
+
+            memories.append(memories_item)
+
+        org_id = d.pop("org_id")
+
+        memoryset_id = d.pop("memoryset_id")
+
+        model_id = d.pop("model_id")
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+        tags = cast(List[str], d.pop("tags"))
+
+        feedbacks = []
+        _feedbacks = d.pop("feedbacks")
+        for feedbacks_item_data in _feedbacks:
+            feedbacks_item = PredictionFeedback.from_dict(feedbacks_item_data)
+
+            feedbacks.append(feedbacks_item)
+
+        label_prediction_with_memories_and_feedback = cls(
+            prediction_id=prediction_id,
+            label=label,
+            label_name=label_name,
+            confidence=confidence,
+            timestamp=timestamp,
+            logits=logits,
+            input_value=input_value,
+            input_embedding=input_embedding,
+            expected_label=expected_label,
+            memories=memories,
+            org_id=org_id,
+            memoryset_id=memoryset_id,
+            model_id=model_id,
+            updated_at=updated_at,
+            tags=tags,
+            feedbacks=feedbacks,
+        )
+
+        label_prediction_with_memories_and_feedback.additional_properties = d
+        return label_prediction_with_memories_and_feedback
+
+    @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/labeled_memory.py

@@ -0,0 +1,197 @@
+"""
+This file is generated by the openapi-python-client tool via the generate_api_client.py script
+
+It is a customized template from the openapi-python-client tool's default template:
+https://github.com/openapi-generators/openapi-python-client/blob/861ef5622f10fc96d240dc9becb0edf94e61446c/openapi_python_client/templates/model.py.jinja
+
+The main change is:
+- Fix typing issues
+"""
+
+# flake8: noqa: C901
+
+import datetime
+from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.labeled_memory_metadata import LabeledMemoryMetadata
+    from ..models.labeled_memory_metrics import LabeledMemoryMetrics
+
+
+T = TypeVar("T", bound="LabeledMemory")
+
+
+@_attrs_define
+class LabeledMemory:
+    """A labeled memory is a single item that can be stored in the database and has a label.
+
+    Attributes:
+        value (str):
+        embedding (List[float]):
+        label (int):
+        label_name (Union[None, str]):
+        source_id (Union[None, str]):
+        metadata (LabeledMemoryMetadata):
+        memory_id (str):
+        memory_version (int):
+        created_at (datetime.datetime):
+        updated_at (datetime.datetime):
+        metrics (Union['LabeledMemoryMetrics', None]):
+    """
+
+    value: str
+    embedding: List[float]
+    label: int
+    label_name: Union[None, str]
+    source_id: Union[None, str]
+    metadata: "LabeledMemoryMetadata"
+    memory_id: str
+    memory_version: int
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
+    metrics: Union["LabeledMemoryMetrics", None]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.labeled_memory_metrics import LabeledMemoryMetrics
+
+        value: str
+        value = self.value
+
+        embedding = self.embedding
+
+        label = self.label
+
+        label_name: Union[None, str]
+        label_name = self.label_name
+
+        source_id: Union[None, str]
+        source_id = self.source_id
+
+        metadata = self.metadata.to_dict()
+
+        memory_id = self.memory_id
+
+        memory_version = self.memory_version
+
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
+        metrics: Union[Dict[str, Any], None]
+        if isinstance(self.metrics, LabeledMemoryMetrics):
+            metrics = self.metrics.to_dict()
+        else:
+            metrics = self.metrics
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "value": value,
+                "embedding": embedding,
+                "label": label,
+                "label_name": label_name,
+                "source_id": source_id,
+                "metadata": metadata,
+                "memory_id": memory_id,
+                "memory_version": memory_version,
+                "created_at": created_at,
+                "updated_at": updated_at,
+                "metrics": metrics,
+            }
+        )
+
+        return field_dict
+
+    @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
+
+        d = src_dict.copy()
+
+        def _parse_value(data: object) -> str:
+            return cast(str, data)
+
+        value = _parse_value(d.pop("value"))
+
+        embedding = cast(List[float], d.pop("embedding"))
+
+        label = d.pop("label")
+
+        def _parse_label_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        label_name = _parse_label_name(d.pop("label_name"))
+
+        def _parse_source_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        source_id = _parse_source_id(d.pop("source_id"))
+
+        metadata = LabeledMemoryMetadata.from_dict(d.pop("metadata"))
+
+        memory_id = d.pop("memory_id")
+
+        memory_version = d.pop("memory_version")
+
+        created_at = isoparse(d.pop("created_at"))
+
+        updated_at = isoparse(d.pop("updated_at"))
+
+        def _parse_metrics(data: object) -> Union["LabeledMemoryMetrics", None]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                metrics_type_0 = LabeledMemoryMetrics.from_dict(data)
+
+                return metrics_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["LabeledMemoryMetrics", None], data)
+
+        metrics = _parse_metrics(d.pop("metrics"))
+
+        labeled_memory = cls(
+            value=value,
+            embedding=embedding,
+            label=label,
+            label_name=label_name,
+            source_id=source_id,
+            metadata=metadata,
+            memory_id=memory_id,
+            memory_version=memory_version,
+            created_at=created_at,
+            updated_at=updated_at,
+            metrics=metrics,
+        )
+
+        labeled_memory.additional_properties = d
+        return labeled_memory
+
+    @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/labeled_memory_insert.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 TYPE_CHECKING, Any, Dict, Type, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.labeled_memory_insert_metadata import LabeledMemoryInsertMetadata
+
+
+T = TypeVar("T", bound="LabeledMemoryInsert")
+
+
+@_attrs_define
+class LabeledMemoryInsert:
+    """Model of fields required for inserting a labeled memory
+
+    Attributes:
+        value (str):
+        label (int):
+        metadata (Union[Unset, LabeledMemoryInsertMetadata]):
+        source_id (Union[None, Unset, str]):
+    """
+
+    value: str
+    label: int
+    metadata: Union[Unset, "LabeledMemoryInsertMetadata"] = UNSET
+    source_id: Union[None, Unset, str] = UNSET
+
+    def to_dict(self) -> dict[str, Any]:
+        value: str
+        value = self.value
+
+        label = self.label
+
+        metadata: Union[Unset, Dict[str, Any]] = UNSET
+        if not isinstance(self.metadata, Unset):
+            metadata = self.metadata.to_dict()
+
+        source_id: Union[None, Unset, str]
+        if isinstance(self.source_id, Unset):
+            source_id = UNSET
+        else:
+            source_id = self.source_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(
+            {
+                "value": value,
+                "label": label,
+            }
+        )
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if source_id is not UNSET:
+            field_dict["source_id"] = source_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: Type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.labeled_memory_insert_metadata import LabeledMemoryInsertMetadata
+
+        d = src_dict.copy()
+
+        def _parse_value(data: object) -> str:
+            return cast(str, data)
+
+        value = _parse_value(d.pop("value"))
+
+        label = d.pop("label")
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, LabeledMemoryInsertMetadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = LabeledMemoryInsertMetadata.from_dict(_metadata)
+
+        def _parse_source_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)
+
+        source_id = _parse_source_id(d.pop("source_id", UNSET))
+
+        labeled_memory_insert = cls(
+            value=value,
+            label=label,
+            metadata=metadata,
+            source_id=source_id,
+        )
+
+        return labeled_memory_insert