opengradient 0.3.23__py3-none-any.whl → 0.3.25__py3-none-any.whl

opengradient/defaults.py

@@ -1,8 +1,8 @@
 # Default variables
-DEFAULT_RPC_URL="http://18.218.115.248:8545"
-DEFAULT_OG_FAUCET_URL="http://18.218.115.248:8080/?address="
-DEFAULT_HUB_SIGNUP_URL="https://hub.opengradient.ai/signup"
-DEFAULT_INFERENCE_CONTRACT_ADDRESS="0x3fDCb0394CF4919ff4361f4EbA0750cEc2e3bBc7"
-DEFAULT_BLOCKCHAIN_EXPLORER="http://3.145.62.2/tx/"
-DEFAULT_IMAGE_GEN_HOST="18.217.25.69"
-DEFAULT_IMAGE_GEN_PORT=5125
+DEFAULT_RPC_URL = "http://18.218.115.248:8545"
+DEFAULT_OG_FAUCET_URL = "http://18.218.115.248:8080/?address="
+DEFAULT_HUB_SIGNUP_URL = "https://hub.opengradient.ai/signup"
+DEFAULT_INFERENCE_CONTRACT_ADDRESS = "0x3fDCb0394CF4919ff4361f4EbA0750cEc2e3bBc7"
+DEFAULT_BLOCKCHAIN_EXPLORER = "http://3.145.62.2/tx/"
+DEFAULT_IMAGE_GEN_HOST = "18.217.25.69"
+DEFAULT_IMAGE_GEN_PORT = 5125

opengradient/exceptions.py

@@ -1,5 +1,6 @@
 class OpenGradientError(Exception):
     """Base exception for OpenGradient SDK"""
+
     def __init__(self, message, status_code=None, response=None):
         self.message = message
         self.status_code = status_code
@@ -9,69 +10,93 @@ class OpenGradientError(Exception):
     def __str__(self):
         return f"{self.message} (Status code: {self.status_code})"
 
+
 class FileNotFoundError(OpenGradientError):
     """Raised when a file is not found"""
+
     def __init__(self, file_path):
         super().__init__(f"File not found: {file_path}")
         self.file_path = file_path
 
+
 class UploadError(OpenGradientError):
     """Raised when there's an error during file upload"""
+
     def __init__(self, message, file_path=None, **kwargs):
         super().__init__(message, **kwargs)
         self.file_path = file_path
 
+
 class InferenceError(OpenGradientError):
     """Raised when there's an error during inference"""
+
     def __init__(self, message, model_cid=None, **kwargs):
         super().__init__(message, **kwargs)
         self.model_cid = model_cid
 
+
 class ResultRetrievalError(OpenGradientError):
     """Raised when there's an error retrieving results"""
+
     def __init__(self, message, inference_cid=None, **kwargs):
         super().__init__(message, **kwargs)
         self.inference_cid = inference_cid
 
+
 class AuthenticationError(OpenGradientError):
     """Raised when there's an authentication error"""
+
     def __init__(self, message="Authentication failed", **kwargs):
         super().__init__(message, **kwargs)
 
+
 class RateLimitError(OpenGradientError):
     """Raised when API rate limit is exceeded"""
+
     def __init__(self, message="Rate limit exceeded", retry_after=None, **kwargs):
         super().__init__(message, **kwargs)
         self.retry_after = retry_after
 
+
 class InvalidInputError(OpenGradientError):
     """Raised when invalid input is provided"""
+
     def __init__(self, message, invalid_fields=None, **kwargs):
         super().__init__(message, **kwargs)
         self.invalid_fields = invalid_fields or []
 
+
 class ServerError(OpenGradientError):
     """Raised when a server error occurs"""
+
     pass
 
+
 class TimeoutError(OpenGradientError):
     """Raised when a request times out"""
+
     def __init__(self, message="Request timed out", timeout=None, **kwargs):
         super().__init__(message, **kwargs)
         self.timeout = timeout
 
+
 class NetworkError(OpenGradientError):
     """Raised when a network error occurs"""
+
     pass
 
+
 class UnsupportedModelError(OpenGradientError):
     """Raised when an unsupported model type is used"""
+
     def __init__(self, model_type):
         super().__init__(f"Unsupported model type: {model_type}")
         self.model_type = model_type
 
+
 class InsufficientCreditsError(OpenGradientError):
     """Raised when the user has insufficient credits for the operation"""
+
     def __init__(self, message="Insufficient credits", required_credits=None, available_credits=None, **kwargs):
         super().__init__(message, **kwargs)
         self.required_credits = required_credits

opengradient/llm/__init__.py

@@ -9,15 +9,14 @@ into existing applications and agent frameworks.
 from .og_langchain import *
 from .og_openai import *
 
+
 def langchain_adapter(private_key: str, model_cid: str, max_tokens: int = 300) -> OpenGradientChatModel:
     """
     Returns an OpenGradient LLM that implements LangChain's LLM interface
     and can be plugged into LangChain agents.
     """
-    return OpenGradientChatModel(
-        private_key=private_key,
-        model_cid=model_cid,
-        max_tokens=max_tokens)
+    return OpenGradientChatModel(private_key=private_key, model_cid=model_cid, max_tokens=max_tokens)
+
 
 def openai_adapter(private_key: str) -> OpenGradientOpenAIClient:
     """
@@ -27,12 +26,10 @@ def openai_adapter(private_key: str) -> OpenGradientOpenAIClient:
     """
     return OpenGradientOpenAIClient(private_key=private_key)
 
+
 __all__ = [
-    'langchain_adapter',
-    'openai_adapter',
+    "langchain_adapter",
+    "openai_adapter",
 ]
 
-__pdoc__ = {
-    'og_langchain': False,
-    'og_openai': False
-}
+__pdoc__ = {"og_langchain": False, "og_openai": False}

opengradient/llm/og_langchain.py

@@ -1,24 +1,22 @@
-from typing import List, Dict, Optional, Any, Sequence, Union
 import json
+from typing import Any, Dict, List, Optional, Sequence, Union
 
 from langchain.chat_models.base import BaseChatModel
 from langchain.schema import (
     AIMessage,
-    HumanMessage,
-    SystemMessage,
     BaseMessage,
-    ChatResult,
     ChatGeneration,
-)
-from langchain_core.messages.tool import (
-    ToolMessage
+    ChatResult,
+    HumanMessage,
+    SystemMessage,
 )
 from langchain_core.callbacks.manager import CallbackManagerForLLMRun
-from langchain_core.tools import BaseTool
 from langchain_core.messages import ToolCall
+from langchain_core.messages.tool import ToolMessage
+from langchain_core.tools import BaseTool
 
 from opengradient import Client, LlmInferenceMode
-from opengradient.defaults import DEFAULT_RPC_URL, DEFAULT_INFERENCE_CONTRACT_ADDRESS
+from opengradient.defaults import DEFAULT_INFERENCE_CONTRACT_ADDRESS, DEFAULT_RPC_URL
 
 
 class OpenGradientChatModel(BaseChatModel):
@@ -32,18 +30,15 @@ class OpenGradientChatModel(BaseChatModel):
     def __init__(self, private_key: str, model_cid: str, max_tokens: int = 300):
         super().__init__()
         self.client = Client(
-            private_key=private_key,
-            rpc_url=DEFAULT_RPC_URL,
-            contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS,
-            email=None,
-            password=None)
+            private_key=private_key, rpc_url=DEFAULT_RPC_URL, contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS, email=None, password=None
+        )
         self.model_cid = model_cid
         self.max_tokens = max_tokens
 
     @property
     def _llm_type(self) -> str:
         return "opengradient"
-    
+
     def bind_tools(
         self,
         tools: Sequence[Union[BaseTool, Dict]],
@@ -52,17 +47,19 @@ class OpenGradientChatModel(BaseChatModel):
         tool_dicts = []
         for tool in tools:
             if isinstance(tool, BaseTool):
-                tool_dicts.append({
-                    "type": "function",
-                    "function": {
-                        "name": tool.name,
-                        "description": tool.description,
-                        "parameters": tool.args_schema.schema() if hasattr(tool, "args_schema") else {}
+                tool_dicts.append(
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": tool.name,
+                            "description": tool.description,
+                            "parameters": tool.args_schema.schema() if hasattr(tool, "args_schema") else {},
+                        },
                     }
-                })
+                )
             else:
                 tool_dicts.append(tool)
-        
+
         self.tools = tool_dicts
         return self
 
@@ -73,7 +70,6 @@ class OpenGradientChatModel(BaseChatModel):
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> ChatResult:
-
         sdk_messages = []
         for message in messages:
             if isinstance(message, SystemMessage):
@@ -81,14 +77,15 @@ class OpenGradientChatModel(BaseChatModel):
             elif isinstance(message, HumanMessage):
                 sdk_messages.append({"role": "user", "content": message.content})
             elif isinstance(message, AIMessage):
-                sdk_messages.append({
-                    "role": "assistant", 
-                    "content": message.content, 
-                    "tool_calls": [{
-                        "id": call["id"],
-                        "name": call["name"],
-                        "arguments": json.dumps(call["args"])
-                    } for call in message.tool_calls]})
+                sdk_messages.append(
+                    {
+                        "role": "assistant",
+                        "content": message.content,
+                        "tool_calls": [
+                            {"id": call["id"], "name": call["name"], "arguments": json.dumps(call["args"])} for call in message.tool_calls
+                        ],
+                    }
+                )
             elif isinstance(message, ToolMessage):
                 sdk_messages.append({"role": "tool", "content": message.content, "tool_call_id": message.tool_call_id})
             else:
@@ -100,33 +97,19 @@ class OpenGradientChatModel(BaseChatModel):
             stop_sequence=stop,
             max_tokens=self.max_tokens,
             tools=self.tools,
-            inference_mode=LlmInferenceMode.VANILLA
+            inference_mode=LlmInferenceMode.VANILLA,
         )
 
         if "tool_calls" in chat_response and chat_response["tool_calls"]:
             tool_calls = []
             for tool_call in chat_response["tool_calls"]:
-                tool_calls.append(
-                    ToolCall(
-                        id=tool_call.get("id", ""),
-                        name=tool_call["name"],
-                        args=json.loads(tool_call["arguments"])
-                    )
-                )
-            
-            message = AIMessage(
-                content='',
-                tool_calls=tool_calls
-            )
+                tool_calls.append(ToolCall(id=tool_call.get("id", ""), name=tool_call["name"], args=json.loads(tool_call["arguments"])))
+
+            message = AIMessage(content="", tool_calls=tool_calls)
         else:
             message = AIMessage(content=chat_response["content"])
 
-        return ChatResult(
-            generations=[ChatGeneration(
-                message=message,
-                generation_info={"finish_reason": finish_reason}
-            )]
-        )
+        return ChatResult(generations=[ChatGeneration(message=message, generation_info={"finish_reason": finish_reason})])
 
     @property
     def _identifying_params(self) -> Dict[str, Any]:

opengradient/llm/og_openai.py

@@ -1,10 +1,12 @@
+import time
+import uuid
+from typing import List
+
 from openai.types.chat import ChatCompletion
+
 import opengradient as og
-from opengradient.defaults import DEFAULT_RPC_URL, DEFAULT_INFERENCE_CONTRACT_ADDRESS
+from opengradient.defaults import DEFAULT_INFERENCE_CONTRACT_ADDRESS, DEFAULT_RPC_URL
 
-from typing import List
-import time
-import uuid
 
 class OGCompletions(object):
     client: og.Client
@@ -13,14 +15,14 @@ class OGCompletions(object):
         self.client = client
 
     def create(
-        self, 
-        model: str, 
-        messages: List[object], 
-        tools: List[object], 
-        tool_choice: str, 
-        stream: bool = False, 
-        parallel_tool_calls: bool = False) -> ChatCompletion:
-
+        self,
+        model: str,
+        messages: List[object],
+        tools: List[object],
+        tool_choice: str,
+        stream: bool = False,
+        parallel_tool_calls: bool = False,
+    ) -> ChatCompletion:
         # convert OpenAI message format so it's compatible with the SDK
         sdk_messages = OGCompletions.convert_to_abi_compatible(messages)
 
@@ -29,38 +31,32 @@ class OGCompletions(object):
             messages=sdk_messages,
             max_tokens=200,
             tools=tools,
-            tool_choice=tool_choice, 
+            tool_choice=tool_choice,
             temperature=0.25,
-            inference_mode=og.LlmInferenceMode.VANILLA
+            inference_mode=og.LlmInferenceMode.VANILLA,
         )
 
         choice = {
-            'index': 0,  # Add missing index field
-            'finish_reason': finish_reason,
-            'message': {
-                'role': chat_completion['role'],
-                'content': chat_completion['content'],
-                'tool_calls': [
+            "index": 0,  # Add missing index field
+            "finish_reason": finish_reason,
+            "message": {
+                "role": chat_completion["role"],
+                "content": chat_completion["content"],
+                "tool_calls": [
                     {
-                        'id': tool_call['id'],
-                        'type': 'function',  # Add missing type field
-                        'function': {        # Add missing function field
-                            'name': tool_call['name'],
-                            'arguments': tool_call['arguments']
-                        }
+                        "id": tool_call["id"],
+                        "type": "function",  # Add missing type field
+                        "function": {  # Add missing function field
+                            "name": tool_call["name"],
+                            "arguments": tool_call["arguments"],
+                        },
                     }
-                    for tool_call in chat_completion.get('tool_calls', [])
-                ] 
-            }
+                    for tool_call in chat_completion.get("tool_calls", [])
+                ],
+            },
         }
 
-        return ChatCompletion(
-            id=str(uuid.uuid4()),
-            created=int(time.time()),
-            model=model,
-            object='chat.completion',
-            choices=[choice]
-        )
+        return ChatCompletion(id=str(uuid.uuid4()), created=int(time.time()), model=model, object="chat.completion", choices=[choice])
 
     @staticmethod
     @staticmethod
@@ -68,53 +64,50 @@ class OGCompletions(object):
         sdk_messages = []
 
         for message in messages:
-            role = message['role']
-            sdk_message = {
-                'role': role
-            }
-
-            if role == 'system':
-                sdk_message['content'] = message['content']
-            elif role == 'user':
-                sdk_message['content'] = message['content']
-            elif role == 'tool':
-                sdk_message['content'] = message['content']
-                sdk_message['tool_call_id'] = message['tool_call_id']
-            elif role == 'assistant':
+            role = message["role"]
+            sdk_message = {"role": role}
+
+            if role == "system":
+                sdk_message["content"] = message["content"]
+            elif role == "user":
+                sdk_message["content"] = message["content"]
+            elif role == "tool":
+                sdk_message["content"] = message["content"]
+                sdk_message["tool_call_id"] = message["tool_call_id"]
+            elif role == "assistant":
                 flattened_calls = []
-                for tool_call in message['tool_calls']:
+                for tool_call in message["tool_calls"]:
                     # OpenAI format
                     flattened_call = {
-                        'id': tool_call['id'],
-                        'name': tool_call['function']['name'],
-                        'arguments': tool_call['function']['arguments']
+                        "id": tool_call["id"],
+                        "name": tool_call["function"]["name"],
+                        "arguments": tool_call["function"]["arguments"],
                     }
                     flattened_calls.append(flattened_call)
 
-                sdk_message['tool_calls'] = flattened_calls
-                sdk_message['content'] = message['content']
+                sdk_message["tool_calls"] = flattened_calls
+                sdk_message["content"] = message["content"]
 
             sdk_messages.append(sdk_message)
 
         return sdk_messages
 
+
 class OGChat(object):
     completions: OGCompletions
 
     def __init__(self, client: og.Client):
         self.completions = OGCompletions(client)
 
+
 class OpenGradientOpenAIClient(object):
     """OpenAI client implementation"""
+
     client: og.Client
     chat: OGChat
 
     def __init__(self, private_key: str):
         self.client = og.Client(
-            private_key=private_key,
-            rpc_url=DEFAULT_RPC_URL,
-            contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS,
-            email=None,
-            password=None
+            private_key=private_key, rpc_url=DEFAULT_RPC_URL, contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS, email=None, password=None
         )
-        self.chat = OGChat(self.client)
+        self.chat = OGChat(self.client)

opengradient/mltools/__init__.py

@@ -4,11 +4,6 @@ OpenGradient AlphaSense Tools
 
 from .model_tool import *
 
-__all__ = [
-    'create_og_model_tool',
-    'ToolType'
-]
+__all__ = ["create_og_model_tool", "ToolType"]
 
-__pdoc__ = {
-    'model_tool': False
-}
+__pdoc__ = {"model_tool": False}

opengradient/mltools/model_tool.py

@@ -1,28 +1,32 @@
 from enum import Enum
-from typing import Callable, Dict, Any, Type
+from typing import Any, Callable, Dict, Type
 
-from pydantic import BaseModel
 from langchain_core.tools import BaseTool, StructuredTool
+from pydantic import BaseModel
+
 import opengradient as og
 
+
 class ToolType(str, Enum):
     """Indicates the framework the tool is compatible with."""
 
     LANGCHAIN = "langchain"
     SWARM = "swarm"
-    
+
     def __str__(self) -> str:
         return self.value
 
+
 def create_og_model_tool(
     tool_type: ToolType,
-    model_cid: str, 
+    model_cid: str,
     tool_name: str,
     input_getter: Callable,
     output_formatter: Callable[..., str],
     input_schema: Type[BaseModel] = None,
-    tool_description: str = "Executes the given ML model", 
-    inference_mode: og.InferenceMode= og.InferenceMode.VANILLA) -> BaseTool:
+    tool_description: str = "Executes the given ML model",
+    inference_mode: og.InferenceMode = og.InferenceMode.VANILLA,
+) -> BaseTool:
     """
     Creates a tool that wraps an OpenGradient model for inference.
 
@@ -32,15 +36,15 @@ def create_og_model_tool(
     runs inference using the specified OpenGradient model.
 
     Args:
-        tool_type (ToolType): Specifies the framework to create the tool for. Use 
+        tool_type (ToolType): Specifies the framework to create the tool for. Use
             ToolType.LANGCHAIN for LangChain integration or ToolType.SWARM for Swarm
-            integration. 
+            integration.
         model_cid (str): The CID of the OpenGradient model to be executed.
         tool_name (str): The name to assign to the created tool. This will be used to identify
             and invoke the tool within the agent.
         input_getter (Callable): A function that returns the input data required by the model.
             The function should return data in a format compatible with the model's expectations.
-        output_formatter (Callable[..., str]): A function that takes the model output and 
+        output_formatter (Callable[..., str]): A function that takes the model output and
             formats it into a string. This is required to ensure the output is compatible
             with the tool framework.
         input_schema (Type[BaseModel], optional): A Pydantic BaseModel class defining the
@@ -78,29 +82,18 @@ def create_og_model_tool(
         ...     tool_description="Classifies text into categories"
         ... )
     """
+
     # define runnable
     def model_executor(**llm_input):
         # Combine LLM input with input provided by code
-        combined_input = {
-            **llm_input,
-            **input_getter()
-        }
+        combined_input = {**llm_input, **input_getter()}
 
-        _, output = og.infer(
-            model_cid=model_cid,
-            inference_mode=inference_mode,
-            model_input=combined_input
-        )
+        _, output = og.infer(model_cid=model_cid, inference_mode=inference_mode, model_input=combined_input)
 
         return output_formatter(output)
 
     if tool_type == ToolType.LANGCHAIN:
-        return StructuredTool.from_function(
-            func=model_executor,
-            name=tool_name,
-            description=tool_description,
-            args_schema=input_schema
-        )
+        return StructuredTool.from_function(func=model_executor, name=tool_name, description=tool_description, args_schema=input_schema)
     elif tool_type == ToolType.SWARM:
         model_executor.__name__ = tool_name
         model_executor.__doc__ = tool_description
@@ -111,13 +104,14 @@ def create_og_model_tool(
     else:
         raise ValueError(f"Invalid tooltype: {tool_type}")
 
+
 def _convert_pydantic_to_annotations(model: Type[BaseModel]) -> Dict[str, Any]:
     """
     Convert a Pydantic model to function annotations format used by Swarm.
-    
+
     Args:
         model: A Pydantic BaseModel class
-        
+
     Returns:
         Dict mapping field names to (type, description) tuples
     """