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

orca_sdk/telemetry.py

@@ -1,34 +1,22 @@
 from __future__ import annotations
 
 import logging
+import os
 from abc import ABC
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Generator, Iterable, Self, overload
-from uuid import UUID
-
-from orca_sdk._utils.common import UNSET
-
-from ._generated_api_client.api import (
-    drop_feedback_category_with_data,
-    get_prediction,
-    list_feedback_categories,
-    list_predictions,
-    record_prediction_feedback,
-    update_prediction,
-)
-from ._generated_api_client.client import get_client
-from ._generated_api_client.errors import get_error_for_response
-from ._generated_api_client.models import (
-    FeedbackType,
+from typing import TYPE_CHECKING, Any, Iterable, Literal, Self, overload
+
+from httpx import Timeout
+
+from ._utils.common import UNSET
+from .client import (
     LabelPredictionWithMemoriesAndFeedback,
-    ListPredictionsRequest,
     PredictionFeedbackCategory,
     PredictionFeedbackRequest,
     ScorePredictionWithMemoriesAndFeedback,
     UpdatePredictionRequest,
+    orca_api,
 )
-from ._generated_api_client.types import UNSET as CLIENT_UNSET
-from ._utils.prediction_result_ui import inspect_prediction_result
 from .memoryset import (
     LabeledMemoryLookup,
     LabeledMemoryset,
@@ -40,6 +28,23 @@ if TYPE_CHECKING:
     from .classification_model import ClassificationModel
     from .regression_model import RegressionModel
 
+TelemetryMode = Literal["off", "on", "sync", "async"]
+"""
+Mode for saving telemetry. One of:
+
+- `"off"`: Do not save telemetry
+- `"on"`: Save telemetry asynchronously unless the `ORCA_SAVE_TELEMETRY_SYNCHRONOUSLY` environment variable is set.
+- `"sync"`: Save telemetry synchronously
+- `"async"`: Save telemetry asynchronously
+"""
+
+
+def _get_telemetry_config(override: TelemetryMode | None = None) -> tuple[bool, bool]:
+    return (
+        override != "off",
+        os.getenv("ORCA_SAVE_TELEMETRY_SYNCHRONOUSLY", "0") != "0" or override == "sync",
+    )
+
 
 def _parse_feedback(feedback: dict[str, Any]) -> PredictionFeedbackRequest:
     category = feedback.get("category", None)
@@ -48,12 +53,15 @@ def _parse_feedback(feedback: dict[str, Any]) -> PredictionFeedbackRequest:
     prediction_id = feedback.get("prediction_id", None)
     if prediction_id is None:
         raise ValueError("`prediction_id` must be specified")
-    return PredictionFeedbackRequest(
-        prediction_id=prediction_id,
-        category_name=category,
-        value=feedback.get("value", CLIENT_UNSET),
-        comment=feedback.get("comment", CLIENT_UNSET),
-    )
+    output: PredictionFeedbackRequest = {
+        "prediction_id": prediction_id,
+        "category_name": category,
+    }
+    if "value" in feedback:
+        output["value"] = feedback["value"]
+    if "comment" in feedback:
+        output["comment"] = feedback["comment"]
+    return output
 
 
 class FeedbackCategory:
@@ -77,11 +85,10 @@ class FeedbackCategory:
     created_at: datetime
 
     def __init__(self, category: PredictionFeedbackCategory):
-        # for internal use only, do not document
-        self.id = category.id
-        self.name = category.name
-        self.value_type = bool if category.type == FeedbackType.BINARY else float
-        self.created_at = category.created_at
+        self.id = category["id"]
+        self.name = category["name"]
+        self.value_type = bool if category["type"] == "BINARY" else float
+        self.created_at = datetime.fromisoformat(category["created_at"])
 
     @classmethod
     def all(cls) -> list[FeedbackCategory]:
@@ -91,7 +98,7 @@ class FeedbackCategory:
         Returns:
             List with information about all existing feedback categories.
         """
-        return [FeedbackCategory(category) for category in list_feedback_categories()]
+        return [FeedbackCategory(category) for category in orca_api.GET("/telemetry/feedback_category")]
 
     @classmethod
     def drop(cls, name: str) -> None:
@@ -108,13 +115,43 @@ class FeedbackCategory:
         Raises:
             LookupError: If the category is not found.
         """
-        drop_feedback_category_with_data(name)
+        orca_api.DELETE("/telemetry/feedback_category/{name_or_id}", params={"name_or_id": name})
         logging.info(f"Deleted feedback category {name} with all associated feedback")
 
     def __repr__(self):
         return "FeedbackCategory({" + f"name: {self.name}, " + f"value_type: {self.value_type}" + "})"
 
 
+class AddMemorySuggestions:
+    suggestions: list[tuple[str, str]]
+    memoryset_id: str
+    model_id: str
+    prediction_id: str
+
+    def __init__(self, suggestions: list[tuple[str, str]], memoryset_id: str, model_id: str, prediction_id: str):
+        self.suggestions = suggestions
+        self.memoryset_id = memoryset_id
+        self.model_id = model_id
+        self.prediction_id = prediction_id
+
+    def __repr__(self):
+        return (
+            "AddMemorySuggestions({"
+            + f"suggestions: {self.suggestions}, "
+            + f"memoryset_id: {self.memoryset_id}, "
+            + f"model_id: {self.model_id}, "
+            + f"prediction_id: {self.prediction_id}"
+            + "})"
+        )
+
+    def apply(self) -> None:
+        memoryset = LabeledMemoryset.open(self.memoryset_id)
+        label_name_to_label = {label_name: label for label, label_name in enumerate(memoryset.label_names)}
+        memoryset.insert(
+            [{"value": suggestion[0], "label": label_name_to_label[suggestion[1]]} for suggestion in self.suggestions]
+        )
+
+
 class _Prediction(ABC):
     prediction_id: str | None
     confidence: float
@@ -151,55 +188,54 @@ class _Prediction(ABC):
     def _telemetry(self) -> LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback:
         # for internal use only, do not document
         if self.__telemetry is None:
-            self.__telemetry = get_prediction(prediction_id=UUID(self.prediction_id))
+            if self.prediction_id is None:
+                raise ValueError("Cannot fetch telemetry with no prediction ID")
+            self.__telemetry = orca_api.GET(
+                "/telemetry/prediction/{prediction_id}", params={"prediction_id": self.prediction_id}
+            )
         return self.__telemetry
 
     @property
     def input_value(self) -> str:
         if self._input_value is not None:
             return self._input_value
-        assert isinstance(self._telemetry.input_value, str)
-        return self._telemetry.input_value
+        assert isinstance(self._telemetry["input_value"], str)
+        return self._telemetry["input_value"]
 
     @property
     def memory_lookups(self) -> list[LabeledMemoryLookup] | list[ScoredMemoryLookup]:
-        match self._telemetry:
-            case LabelPredictionWithMemoriesAndFeedback():
-                return [
-                    LabeledMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories
-                ]
-            case ScorePredictionWithMemoriesAndFeedback():
-                return [ScoredMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories]
+        if "label" in self._telemetry:
+            return [
+                LabeledMemoryLookup(self._telemetry["memoryset_id"], lookup) for lookup in self._telemetry["memories"]
+            ]
+        else:
+            return [
+                ScoredMemoryLookup(self._telemetry["memoryset_id"], lookup) for lookup in self._telemetry["memories"]
+            ]
 
     @property
     def feedback(self) -> dict[str, bool | float]:
         return {
-            f.category_name: (
-                f.value if f.category_type == FeedbackType.CONTINUOUS else True if f.value == 1 else False
+            f["category_name"]: (
+                f["value"] if f["category_type"] == "CONTINUOUS" else True if f["value"] == 1 else False
             )
-            for f in self._telemetry.feedbacks
+            for f in self._telemetry["feedbacks"]
         }
 
     @property
     def tags(self) -> set[str]:
-        return set(self._telemetry.tags)
-
-    def _explanation_stream(self, refresh: bool = False) -> Generator[str, None, None]:
-        httpx_client = get_client().get_httpx_client()
-        url = f"/telemetry/prediction/{self.prediction_id}/explanation?refresh={refresh}"
-        with httpx_client.stream("GET", url) as res:
-            if res.status_code != 200:
-                # Read the response body before raising the error
-                res.read()
-                raise get_error_for_response(res)
-            for chunk in res.iter_text():
-                yield chunk
+        return set(self._telemetry["tags"])
 
     @property
     def explanation(self) -> str:
-        if self._telemetry.explanation is None:
-            self._telemetry.explanation = "".join(self._explanation_stream())
-        return self._telemetry.explanation
+        if self._telemetry["explanation"] is None:
+            self._telemetry["explanation"] = orca_api.GET(
+                "/telemetry/prediction/{prediction_id}/explanation",
+                params={"prediction_id": self._telemetry["prediction_id"]},
+                parse_as="text",
+                timeout=30,
+            )
+        return self._telemetry["explanation"]
 
     def explain(self, refresh: bool = False) -> None:
         """
@@ -208,11 +244,16 @@ class _Prediction(ABC):
         Params:
             refresh: Force the explanation agent to re-run even if an explanation already exists.
         """
-        if not refresh and self._telemetry.explanation is not None:
-            print(self._telemetry.explanation)
+        if not refresh and self._telemetry["explanation"] is not None:
+            print(self._telemetry["explanation"])
         else:
-            for chunk in self._explanation_stream(refresh):
-                print(chunk, end="")
+            with orca_api.stream(
+                "GET",
+                f"/telemetry/prediction/{self.prediction_id}/explanation?refresh={refresh}",
+                timeout=Timeout(connect=3, read=None),
+            ) as res:
+                for chunk in res.iter_text():
+                    print(chunk, end="")
             print()  # final newline
 
     @overload
@@ -281,34 +322,33 @@ class _Prediction(ABC):
             prediction: LabelPredictionWithMemoriesAndFeedback | ScorePredictionWithMemoriesAndFeedback,
         ) -> Self:
 
-            if isinstance(prediction, LabelPredictionWithMemoriesAndFeedback):
-                memoryset = LabeledMemoryset.open(prediction.memoryset_id)
-                model = ClassificationModel.open(prediction.model_id)
-            elif isinstance(prediction, ScorePredictionWithMemoriesAndFeedback):
-                memoryset = ScoredMemoryset.open(prediction.memoryset_id)
-                model = RegressionModel.open(prediction.model_id)
+            if "label" in prediction:
+                memoryset = LabeledMemoryset.open(prediction["memoryset_id"])
+                model = ClassificationModel.open(prediction["model_id"])
             else:
-                raise ValueError(f"Invalid prediction type: {type(prediction)}")
+                memoryset = ScoredMemoryset.open(prediction["memoryset_id"])
+                model = RegressionModel.open(prediction["model_id"])
 
             return cls(
-                prediction_id=prediction.prediction_id,
-                label=getattr(prediction, "label", None),
-                label_name=getattr(prediction, "label_name", None),
-                score=getattr(prediction, "score", None),
-                confidence=prediction.confidence,
-                anomaly_score=prediction.anomaly_score,
+                prediction_id=prediction["prediction_id"],
+                label=prediction.get("label", None),
+                label_name=prediction.get("label_name", None),
+                score=prediction.get("score", None),
+                confidence=prediction["confidence"],
+                anomaly_score=prediction["anomaly_score"],
                 memoryset=memoryset,
                 model=model,
                 telemetry=prediction,
             )
 
         if isinstance(prediction_id, str):
-            prediction = get_prediction(prediction_id=UUID(prediction_id))
-            return create_prediction(prediction)
+            return create_prediction(
+                orca_api.GET("/telemetry/prediction/{prediction_id}", params={"prediction_id": prediction_id})
+            )
         else:
             return [
                 create_prediction(prediction)
-                for prediction in list_predictions(body=ListPredictionsRequest(prediction_ids=list(prediction_id)))
+                for prediction in orca_api.POST("/telemetry/prediction", json={"prediction_ids": list(prediction_id)})
             ]
 
     def refresh(self):
@@ -327,13 +367,15 @@ class _Prediction(ABC):
         if self.prediction_id is None:
             raise ValueError("Cannot update prediction with no prediction ID")
 
-        update_prediction(
-            prediction_id=self.prediction_id,
-            body=UpdatePredictionRequest(
-                expected_label=expected_label if expected_label is not UNSET else CLIENT_UNSET,
-                expected_score=expected_score if expected_score is not UNSET else CLIENT_UNSET,
-                tags=[] if tags is None else list(tags) if tags is not UNSET else CLIENT_UNSET,
-            ),
+        payload: UpdatePredictionRequest = {}
+        if tags is not UNSET:
+            payload["tags"] = [] if tags is None else list(tags)
+        if expected_label is not UNSET:
+            payload["expected_label"] = expected_label
+        if expected_score is not UNSET:
+            payload["expected_score"] = expected_score
+        orca_api.PATCH(
+            "/telemetry/prediction/{prediction_id}", params={"prediction_id": self.prediction_id}, json=payload
         )
         self.refresh()
 
@@ -389,12 +431,13 @@ class _Prediction(ABC):
             ValueError: If the value does not match previous value types for the category, or is a
                 [`float`][float] that is not between `-1.0` and `+1.0`.
         """
-        record_prediction_feedback(
-            body=[
+        orca_api.PUT(
+            "/telemetry/prediction/feedback",
+            json=[
                 _parse_feedback(
                     {"prediction_id": self.prediction_id, "category": category, "value": value, "comment": comment}
                 )
-            ]
+            ],
         )
         self.refresh()
 
@@ -411,23 +454,12 @@ class _Prediction(ABC):
         if self.prediction_id is None:
             raise ValueError("Cannot delete feedback with no prediction ID")
 
-        record_prediction_feedback(
-            body=[PredictionFeedbackRequest(prediction_id=self.prediction_id, category_name=category, value=None)]
+        orca_api.PUT(
+            "/telemetry/prediction/feedback",
+            json=[PredictionFeedbackRequest(prediction_id=self.prediction_id, category_name=category, value=None)],
         )
         self.refresh()
 
-    def inspect(self) -> None:
-        """
-        Display an interactive UI with the details about this prediction
-
-        Params:
-            **kwargs: Additional keyword arguments to pass to the display function
-
-        Note:
-            This method is only available in Jupyter notebooks.
-        """
-        inspect_prediction_result(self)  # type: ignore
-
 
 class ClassificationPrediction(_Prediction):
     """
@@ -468,18 +500,18 @@ class ClassificationPrediction(_Prediction):
 
     @property
     def memory_lookups(self) -> list[LabeledMemoryLookup]:
-        assert isinstance(self._telemetry, LabelPredictionWithMemoriesAndFeedback)
-        return [LabeledMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories]
+        assert "label" in self._telemetry
+        return [LabeledMemoryLookup(self._telemetry["memoryset_id"], lookup) for lookup in self._telemetry["memories"]]
 
     @property
     def expected_label(self) -> int | None:
-        assert isinstance(self._telemetry, LabelPredictionWithMemoriesAndFeedback)
-        return self._telemetry.expected_label
+        assert "label" in self._telemetry
+        return self._telemetry["expected_label"]
 
     @property
     def expected_label_name(self) -> str | None:
-        assert isinstance(self._telemetry, LabelPredictionWithMemoriesAndFeedback)
-        return self._telemetry.expected_label_name
+        assert "label" in self._telemetry
+        return self._telemetry["expected_label_name"]
 
     def update(
         self,
@@ -499,6 +531,88 @@ class ClassificationPrediction(_Prediction):
         """
         self._update(tags=tags, expected_label=expected_label)
 
+    def recommend_action(self, *, refresh: bool = False) -> tuple[str, str]:
+        """
+        Get an action recommendation for improving this prediction.
+
+        Analyzes the prediction and suggests the most effective action to improve model
+        performance, such as adding memories, detecting mislabels, removing duplicates,
+        or finetuning.
+
+        Params:
+            refresh: Force the action recommendation agent to re-run even if a recommendation already exists
+
+        Returns:
+            Tuple of (action, rationale) where:
+            - action: The recommended action ("add_memories", "detect_mislabels", "remove_duplicates", or "finetuning") that would resolve the mislabeling
+            - rationale: Explanation for why this action was recommended
+
+        Raises:
+            ValueError: If the prediction has no prediction ID
+            RuntimeError: If the lighthouse API key is not configured
+
+        Examples:
+            Get action recommendation for an incorrect prediction:
+            >>> action, rationale = prediction.recommend_action()
+            >>> print(f"Recommended action: {action}")
+            >>> print(f"Rationale: {rationale}")
+        """
+        if self.prediction_id is None:
+            raise ValueError("Cannot get action recommendation with no prediction ID")
+
+        response = orca_api.GET(
+            "/telemetry/prediction/{prediction_id}/action",
+            params={"prediction_id": self.prediction_id, "refresh": refresh},
+            timeout=30,
+        )
+        return (response["action"], response["rationale"])
+
+    def generate_memory_suggestions(self, *, num_memories: int = 3) -> AddMemorySuggestions:
+        """
+        Generate synthetic memory suggestions to improve this prediction.
+
+        Creates new example memories that are similar to the input but have clearer
+        signals for the expected label. These can be added to the memoryset to improve
+        model performance on similar inputs.
+
+        Params:
+            num_memories: Number of memory suggestions to generate (default: 3)
+
+        Returns:
+            List of dictionaries that can be directly passed to memoryset.insert().
+            Each dictionary contains:
+            - "value": The suggested memory text
+            - "label": The suggested label as an integer
+
+        Raises:
+            ValueError: If the prediction has no prediction ID
+            RuntimeError: If the lighthouse API key is not configured
+
+        Examples:
+            Generate memory suggestions for an incorrect prediction:
+            >>> suggestions = prediction.generate_memory_suggestions(num_memories=3)
+            >>> for suggestion in suggestions:
+            ...     print(f"Value: {suggestion['value']}, Label: {suggestion['label']}")
+            >>>
+            >>> # Add suggestions directly to memoryset
+            >>> model.memoryset.insert(suggestions)
+        """
+        if self.prediction_id is None:
+            raise ValueError("Cannot generate memory suggestions with no prediction ID")
+
+        response = orca_api.GET(
+            "/telemetry/prediction/{prediction_id}/memory_suggestions",
+            params={"prediction_id": self.prediction_id, "num_memories": num_memories},
+            timeout=30,
+        )
+
+        return AddMemorySuggestions(
+            suggestions=[(m["value"], m["label_name"]) for m in response["memories"]],
+            memoryset_id=self.memoryset.id,
+            model_id=self.model.id,
+            prediction_id=self.prediction_id,
+        )
+
 
 class RegressionPrediction(_Prediction):
     """
@@ -535,8 +649,8 @@ class RegressionPrediction(_Prediction):
 
     @property
     def memory_lookups(self) -> list[ScoredMemoryLookup]:
-        assert isinstance(self._telemetry, ScorePredictionWithMemoriesAndFeedback)
-        return [ScoredMemoryLookup(self._telemetry.memoryset_id, lookup) for lookup in self._telemetry.memories]
+        assert "score" in self._telemetry
+        return [ScoredMemoryLookup(self._telemetry["memoryset_id"], lookup) for lookup in self._telemetry["memories"]]
 
     @property
     def explanation(self) -> str:
@@ -545,8 +659,8 @@ class RegressionPrediction(_Prediction):
 
     @property
     def expected_score(self) -> float | None:
-        assert isinstance(self._telemetry, ScorePredictionWithMemoriesAndFeedback)
-        return self._telemetry.expected_score
+        assert "score" in self._telemetry
+        return self._telemetry["expected_score"]
 
     def update(
         self,

{orca_sdk-0.0.96.dist-info → orca_sdk-0.0.98.dist-info}/METADATA

@@ -1,23 +1,20 @@
 Metadata-Version: 2.1
 Name: orca_sdk
-Version: 0.0.96
+Version: 0.0.98
 Summary: SDK for interacting with Orca Services
 License: Apache-2.0
 Author: Orca DB Inc.
 Author-email: dev-rel@orcadb.ai
-Requires-Python: >=3.10,<3.13
+Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: attrs (>=22.2.0)
 Requires-Dist: datasets (>=3.1.0,<4.0.0)
 Requires-Dist: gradio (==5.13.0)
 Requires-Dist: httpx (>=0.20.0,<0.29.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pyarrow (>=18.0.0,<19.0.0)
-Requires-Dist: python-dateutil (>=2.8.0,<3.0.0)
 Requires-Dist: python-dotenv (>=1.1.0,<2.0.0)
 Requires-Dist: scikit-learn (>=1.6.1,<2.0.0)
 Requires-Dist: torch (>=2.5.1,<3.0.0)
@@ -71,6 +68,23 @@ model = ClassificationModel("my_model", memoryset)
 
 # Make predictions
 prediction = model.predict("my input")
+
+# Get Action Recommendation
+action, rationale = prediction.recommend_action()
+print(f"Recommended action: {action}")
+print(f"Rationale: {rationale}")
+
+# Generate and add synthetic memory suggestions
+if action == "add_memories":
+    suggestions = prediction.generate_memory_suggestions(num_memories=3)
+
+    # Review suggestions
+    for suggestion in suggestions:
+        print(f"Suggested: '{suggestion['value']}' -> {suggestion['label']}")
+
+    # Add suggestions to memoryset
+    model.memoryset.insert(suggestions)
+    print(f"Added {len(suggestions)} new memories to improve model performance!")
 ```
 
 For a more detailed walkthrough, check out our [Quick Start Guide](https://docs.orcadb.ai/quickstart-sdk/).

orca_sdk-0.0.98.dist-info/RECORD

@@ -0,0 +1,40 @@
+orca_sdk/__init__.py,sha256=bNbT7BlBGo5ZWYHBiPUz77dIc344l7czz7AsuBrdzyM,1001
+orca_sdk/_shared/__init__.py,sha256=3Kt0Hu3QLI5FEp9nqGTxqAm3hAoBJKcagfaGQZ-lbJQ,223
+orca_sdk/_shared/metrics.py,sha256=KDvnvWjfrC_Znihz12HH83Mll2p3LPlBPBEKJTczVlw,13269
+orca_sdk/_shared/metrics_test.py,sha256=3LQ10RcDeq92rmRQgzyq9WCthhEc7yAwe8WKzUoZGx4,7890
+orca_sdk/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+orca_sdk/_utils/analysis_ui.py,sha256=nT-M_YcNRCVPQzvuqYNFKnNHhYkADYBvq1GlIUePrWw,9232
+orca_sdk/_utils/analysis_ui_style.css,sha256=q_ba_-_KtgztepHg829zLzypaxKayl7ySC1-oYDzV3k,836
+orca_sdk/_utils/auth.py,sha256=58Gaa4KA9iy7WP-hMZT4PI6x5lkpctFbbJ6Piwu1ZS4,2484
+orca_sdk/_utils/auth_test.py,sha256=ygVWv1Ex53LaxIP7p2hzPHl8l9qYyBD5IGmEFJMps6s,1056
+orca_sdk/_utils/common.py,sha256=wUm2pNDWytEecC5WiDWd02-yCZw3Akx0bIutG4lHsFA,805
+orca_sdk/_utils/data_parsing.py,sha256=gkAwWEC8qRt3vRUObe7n7Pr0azOayNwc2yFY04WFp7E,5220
+orca_sdk/_utils/data_parsing_test.py,sha256=fNEYzPzE1jt3KWE2Kj91KqIeuv-L5REHFAa98zkNGSQ,8962
+orca_sdk/_utils/pagination.py,sha256=986z0QPZixrZeurJWorF6eMgnTRdDF84AagEA6qNbMw,4245
+orca_sdk/_utils/pagination_test.py,sha256=BUylCrcHnwoKEBmMUzVr0lwLpA35ivcCwdBK4rMw9y8,4887
+orca_sdk/_utils/prediction_result_ui.css,sha256=sqBlkRLnovb5X5EcUDdB6iGpH63nVRlTW4uAmXuD0WM,258
+orca_sdk/_utils/prediction_result_ui.py,sha256=WxsIHVLvJW0yE6QrBQHWn0BjPUFcDYNF3DTtTjIhgrU,4627
+orca_sdk/_utils/tqdm_file_reader.py,sha256=Lw7Cg1UgNuRUoN6jjqZb-IlV00H-kbRcrZLdudr1GxE,324
+orca_sdk/_utils/value_parser.py,sha256=c3qMABCCDQcIjn9N1orYYnlRwDW9JWdGwW_2TDZPLdI,1286
+orca_sdk/_utils/value_parser_test.py,sha256=OybsiC-Obi32RRi9NIuwrVBRAnlyPMV1xVAaevSrb7M,1079
+orca_sdk/classification_model.py,sha256=SUiUgv_o3UUngpz3Le_L6DsijhjXVEB3yo84hrD1MX4,31172
+orca_sdk/classification_model_test.py,sha256=WganVoP-0vw1cqiVWJ2vXyGi4lwYp_hbZHultpxvFqk,19536
+orca_sdk/client.py,sha256=LEqdqMHbidh9NeZ_42RbEDR64KqXnqnX0JBjaoo2pnY,115704
+orca_sdk/conftest.py,sha256=LHA46gDU_D0T_ogS6XOVQvGDDMD01nVZFWVcBYDConc,8885
+orca_sdk/credentials.py,sha256=KrmgP_5uqBKJXFJV6utTHIhU2odsr95VEqEXWe277DY,5074
+orca_sdk/credentials_test.py,sha256=whUweSJIEws6C8Bku-5V31Dv9hD1mFDDW7X2cCsB6g0,1629
+orca_sdk/datasource.py,sha256=344gqZsSV_N3RDlqXuLnDrPSizvciaAsSPmsiljNSmI,19329
+orca_sdk/datasource_test.py,sha256=nKQGjhX0VwCCLCdwl1ns-6kA5Ow-8pWQkSS9WV3CVww,9975
+orca_sdk/embedding_model.py,sha256=YxMXdZ3tvnxnK93nArOr_HZ6QoRB-Mc5VNQJ0mcIdpk,26021
+orca_sdk/embedding_model_test.py,sha256=1aELyCuIzxSxUg7Z4tYtNOd8-hV5hFb-gsZTNh712OQ,7765
+orca_sdk/job.py,sha256=wWJPkkQbkNu_ylBtZN4AscU00VwWTfqlSmysRBUlivw,12787
+orca_sdk/job_test.py,sha256=r4zCyCuJ8eVN-O6_IUSakmSBn64rY7oBmlNtb5RNsi0,3919
+orca_sdk/memoryset.py,sha256=hnhgHxsuV5JEDMnxazmO03VjxzPBENtHDPppHRfh9z4,85354
+orca_sdk/memoryset_test.py,sha256=14WG6u_adVmm6CSn2dM5lEfQYxybwh3s9Q7RBeTuoPE,20486
+orca_sdk/regression_model.py,sha256=je2g1BmoPCuouv5iWqDolja90F2w2vD6TooXA8KjL7c,24552
+orca_sdk/regression_model_test.py,sha256=8LDhtQeh52grZQ2Xd0ju1MQvb_hwosY_ORDDE3wS2LA,14570
+orca_sdk/telemetry.py,sha256=jOOFYYr1s3i5EASbCcmUJ_O469xCK5OFg7NVcVfTAlU,25400
+orca_sdk/telemetry_test.py,sha256=eT66C5lFdNg-pQdo2I__BP7Tn5fTc9aTkVo9ZhWwhU0,5519
+orca_sdk-0.0.98.dist-info/METADATA,sha256=z5MKWnC226a5mzHHN7aKJFvpFm9qTe46-gtaRTH8ppM,3613
+orca_sdk-0.0.98.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+orca_sdk-0.0.98.dist-info/RECORD,,

orca_sdk/_generated_api_client/__init__.py

@@ -1,3 +0,0 @@
-import logging
-
-logging.getLogger("httpx").setLevel(logging.WARNING)