rm exception

Author: balogh.adam@icloud.com

src/opengradient/client/_utils.py

@@ -3,8 +3,6 @@
 from pathlib import Path
 from typing import Callable
 
-from .exceptions import OpenGradientError
-
 _ABI_DIR = Path(__file__).parent.parent / "abi"
 _BIN_DIR = Path(__file__).parent.parent / "bin"
 
@@ -58,7 +56,7 @@ def run_with_retry(
 
             if any(error in error_msg for error in _NONCE_ERRORS):
                 if attempt == effective_retries - 1:
-                    raise OpenGradientError(f"Transaction failed after {effective_retries} attempts: {e}")
+                    raise RuntimeError(f"Transaction failed after {effective_retries} attempts: {e}")
                 time.sleep(retry_delay)
                 continue
 

src/opengradient/client/alpha.py

@@ -21,7 +21,6 @@
 from ..types import HistoricalInputQuery, InferenceMode, InferenceResult, ModelOutput, SchedulerParams
 from ._conversions import convert_array_to_model_output, convert_to_model_input, convert_to_model_output
 from ._utils import get_abi, get_bin, run_with_retry
-from .exceptions import OpenGradientError
 
 # How much time we wait for txn to be included in chain
 INFERENCE_TX_TIMEOUT = 120
@@ -91,7 +90,7 @@ def infer(
                 model_output (Dict[str, np.ndarray]): Output of the ONNX model
 
         Raises:
-            OpenGradientError: If the inference fails.
+            RuntimeError: If the inference fails.
         """
 
         def execute_transaction():
@@ -106,7 +105,7 @@ def execute_transaction():
             tx_hash, tx_receipt = self._send_tx_with_revert_handling(run_function)
             parsed_logs = contract.events.InferenceResult().process_receipt(tx_receipt, errors=DISCARD)
             if len(parsed_logs) < 1:
-                raise OpenGradientError("InferenceResult event not found in transaction logs")
+                raise RuntimeError("InferenceResult event not found in transaction logs")
 
             # TODO: This should return a ModelOutput class object
             model_output = convert_to_model_output(parsed_logs[0]["args"])
@@ -184,7 +183,7 @@ def _get_inference_result_from_node(self, inference_id: str, inference_mode: Inf
             Dict: The inference result as returned by the node
 
         Raises:
-            OpenGradientError: If the request fails or returns an error
+            RuntimeError: If the request fails or returns an error
         """
         try:
             encoded_id = urllib.parse.quote(inference_id, safe="")
@@ -199,50 +198,50 @@ def _get_inference_result_from_node(self, inference_id: str, inference_mode: Inf
                     decoded_string = decoded_bytes.decode("utf-8")
                     output = json.loads(decoded_string).get("InferenceResult", {})
                     if output is None:
-                        raise OpenGradientError("Missing InferenceResult in inference output")
+                        raise RuntimeError("Missing InferenceResult in inference output")
 
                     match inference_mode:
                         case InferenceMode.VANILLA:
                             if "VanillaResult" not in output:
-                                raise OpenGradientError("Missing VanillaResult in inference output")
+                                raise RuntimeError("Missing VanillaResult in inference output")
                             if "model_output" not in output["VanillaResult"]:
-                                raise OpenGradientError("Missing model_output in VanillaResult")
+                                raise RuntimeError("Missing model_output in VanillaResult")
                             return {"output": output["VanillaResult"]["model_output"]}
 
                         case InferenceMode.TEE:
                             if "TeeNodeResult" not in output:
-                                raise OpenGradientError("Missing TeeNodeResult in inference output")
+                                raise RuntimeError("Missing TeeNodeResult in inference output")
                             if "Response" not in output["TeeNodeResult"]:
-                                raise OpenGradientError("Missing Response in TeeNodeResult")
+                                raise RuntimeError("Missing Response in TeeNodeResult")
                             if "VanillaResponse" in output["TeeNodeResult"]["Response"]:
                                 if "model_output" not in output["TeeNodeResult"]["Response"]["VanillaResponse"]:
-                                    raise OpenGradientError("Missing model_output in VanillaResponse")
+                                    raise RuntimeError("Missing model_output in VanillaResponse")
                                 return {"output": output["TeeNodeResult"]["Response"]["VanillaResponse"]["model_output"]}
 
                             else:
-                                raise OpenGradientError("Missing VanillaResponse in TeeNodeResult Response")
+                                raise RuntimeError("Missing VanillaResponse in TeeNodeResult Response")
 
                         case InferenceMode.ZKML:
                             if "ZkmlResult" not in output:
-                                raise OpenGradientError("Missing ZkmlResult in inference output")
+                                raise RuntimeError("Missing ZkmlResult in inference output")
                             if "model_output" not in output["ZkmlResult"]:
-                                raise OpenGradientError("Missing model_output in ZkmlResult")
+                                raise RuntimeError("Missing model_output in ZkmlResult")
                             return {"output": output["ZkmlResult"]["model_output"]}
 
                         case _:
-                            raise OpenGradientError(f"Invalid inference mode: {inference_mode}")
+                            raise ValueError(f"Invalid inference mode: {inference_mode}")
                 else:
                     return None
 
             else:
-                raise OpenGradientError(f"Failed to get inference result: HTTP {response.status_code}")
+                raise RuntimeError(f"Failed to get inference result: HTTP {response.status_code}")
 
         except requests.RequestException as e:
-            raise OpenGradientError(f"Failed to get inference result: {str(e)}")
-        except OpenGradientError:
+            raise RuntimeError(f"Failed to get inference result: {str(e)}")
+        except (RuntimeError, ValueError):
             raise
         except Exception as e:
-            raise OpenGradientError(f"Failed to get inference result: {str(e)}")
+            raise RuntimeError(f"Failed to get inference result: {str(e)}")
 
     def new_workflow(
         self,

src/opengradient/client/exceptions.py

@@ -14,7 +14,6 @@
 from x402v2.mechanisms.evm.upto.register import register_upto_evm_client as register_upto_evm_clientv2
 
 from ..types import TEE_LLM, StreamChoice, StreamChunk, StreamDelta, TextGenerationOutput, x402SettlementMode
-from .exceptions import OpenGradientError
 from .opg_token import Permit2ApprovalResult, ensure_opg_approval
 from .tee_registry import TEERegistry, build_ssl_context_from_der
 
@@ -186,7 +185,7 @@ def ensure_opg_approval(self, opg_amount: float) -> Permit2ApprovalResult:
 
         Raises:
             ValueError: If the OPG amount is less than 0.05.
-            OpenGradientError: If the approval transaction fails.
+            RuntimeError: If the approval transaction fails.
         """
         if opg_amount < 0.05:
             raise ValueError("OPG amount must be at least 0.05.")
@@ -223,7 +222,7 @@ async def completion(
                 - Payment hash for x402 transactions
 
         Raises:
-            OpenGradientError: If the inference fails.
+            RuntimeError: If the inference fails.
         """
         model_id = model.split("/")[1]
         headers = self._headers(x402_settlement_mode)
@@ -253,10 +252,10 @@ async def completion(
                 tee_timestamp=result.get("tee_timestamp"),
                 **self._tee_metadata(),
             )
-        except OpenGradientError:
+        except RuntimeError:
             raise
         except Exception as e:
-            raise OpenGradientError(f"TEE LLM completion failed: {e}") from e
+            raise RuntimeError(f"TEE LLM completion failed: {e}") from e
 
     async def chat(
         self,
@@ -294,7 +293,7 @@ async def chat(
                 - If stream=True: Async generator yielding StreamChunk objects
 
         Raises:
-            OpenGradientError: If the inference fails.
+            RuntimeError: If the inference fails.
         """
         params = _ChatParams(
             model=model.split("/")[1],
@@ -336,7 +335,7 @@ async def _chat_request(self, params: _ChatParams, messages: List[Dict]) -> Text
 
             choices = result.get("choices")
             if not choices:
-                raise OpenGradientError(f"Invalid response: 'choices' missing or empty in {result}")
+                raise RuntimeError(f"Invalid response: 'choices' missing or empty in {result}")
 
             message = choices[0].get("message", {})
             content = message.get("content")
@@ -353,10 +352,10 @@ async def _chat_request(self, params: _ChatParams, messages: List[Dict]) -> Text
                 tee_timestamp=result.get("tee_timestamp"),
                 **self._tee_metadata(),
             )
-        except OpenGradientError:
+        except RuntimeError:
             raise
         except Exception as e:
-            raise OpenGradientError(f"TEE LLM chat failed: {e}") from e
+            raise RuntimeError(f"TEE LLM chat failed: {e}") from e
 
     async def _chat_tools_as_stream(self, params: _ChatParams, messages: List[Dict]) -> AsyncGenerator[StreamChunk, None]:
         """Non-streaming fallback for tool-call requests wrapped as a single StreamChunk."""
@@ -403,7 +402,7 @@ async def _parse_sse_response(self, response) -> AsyncGenerator[StreamChunk, Non
         status_code = getattr(response, "status_code", None)
         if status_code is not None and status_code >= 400:
             body = await response.aread()
-            raise OpenGradientError(f"TEE LLM streaming request failed with status {status_code}: {body.decode('utf-8', errors='replace')}")
+            raise RuntimeError(f"TEE LLM streaming request failed with status {status_code}: {body.decode('utf-8', errors='replace')}")
 
         buffer = b""
         async for raw_chunk in response.aiter_raw():

src/opengradient/client/llm.py

@@ -8,7 +8,6 @@
 from requests_toolbelt import MultipartEncoder  # type: ignore[import-untyped]
 
 from ..types import FileUploadResult, ModelRepository
-from .exceptions import OpenGradientError
 
 # Security Update: Credentials moved to environment variables
 _FIREBASE_CONFIG = {
@@ -72,7 +71,7 @@ def create_model(self, model_name: str, model_desc: str, version: str = "1.00")
             response.raise_for_status()
         except requests.HTTPError as e:
             error_details = f"HTTP {e.response.status_code}: {e.response.text}"
-            raise OpenGradientError(f"Model creation failed: {error_details}") from e
+            raise RuntimeError(f"Model creation failed: {error_details}") from e
 
         json_response = response.json()
         model_name = json_response.get("name")
@@ -140,7 +139,7 @@ def upload(self, model_path: str, model_name: str, version: str) -> FileUploadRe
             dict: The processed result.
 
         Raises:
-            OpenGradientError: If the upload fails.
+            RuntimeError: If the upload fails.
         """
 
         if not self._hub_user:
@@ -166,17 +165,17 @@ def upload(self, model_path: str, model_name: str, version: str) -> FileUploadRe
                     else:
                         raise RuntimeError("Empty or null response content received")
                 elif response.status_code == 500:
-                    raise OpenGradientError("Internal server error occurred", status_code=500)
+                    raise RuntimeError("Internal server error occurred", status_code=500)
                 else:
                     error_message = response.json().get("detail", "Unknown error occurred")
-                    raise OpenGradientError(f"Upload failed: {error_message}", status_code=response.status_code)
+                    raise RuntimeError(f"Upload failed: {error_message}", status_code=response.status_code)
 
         except requests.RequestException as e:
-            raise OpenGradientError(f"Upload failed: {str(e)}")
-        except OpenGradientError:
+            raise RuntimeError(f"Upload failed: {str(e)}")
+        except RuntimeError:
             raise
         except Exception as e:
-            raise OpenGradientError(f"Unexpected error during upload: {str(e)}")
+            raise RuntimeError(f"Unexpected error during upload: {str(e)}")
 
     def list_files(self, model_name: str, version: str) -> List[Dict]:
         """
@@ -190,7 +189,7 @@ def list_files(self, model_name: str, version: str) -> List[Dict]:
             List[Dict]: A list of dictionaries containing file information.
 
         Raises:
-            OpenGradientError: If the file listing fails.
+            RuntimeError: If the file listing fails.
         """
         if not self._hub_user:
             raise ValueError("User not authenticated")
@@ -204,6 +203,6 @@ def list_files(self, model_name: str, version: str) -> List[Dict]:
             return response.json()
 
         except requests.RequestException as e:
-            raise OpenGradientError(f"File listing failed: {str(e)}")
+            raise RuntimeError(f"File listing failed: {str(e)}")
         except Exception as e:
-            raise OpenGradientError(f"Unexpected error during file listing: {str(e)}")
+            raise RuntimeError(f"Unexpected error during file listing: {str(e)}")