opengradient 0.3.24__tar.gz → 0.3.25__tar.gz

{opengradient-0.3.24/src/opengradient.egg-info → opengradient-0.3.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: opengradient
-Version: 0.3.24
+Version: 0.3.25
 Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License

{opengradient-0.3.24 → opengradient-0.3.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opengradient"
-version = "0.3.24"
+version = "0.3.25"
 description = "Python SDK for OpenGradient decentralized model management & inference services"
 authors = [{name = "OpenGradient", email = "oliver@opengradient.ai"}]
 license = {file = "LICENSE"}

{opengradient-0.3.24 → opengradient-0.3.25}/src/opengradient/__init__.py

@@ -1,21 +1,36 @@
 """
 OpenGradient Python SDK for interacting with AI models and infrastructure.
 """
-from typing import Dict, List, Optional, Tuple, Any, Union
-from pathlib import Path
+
+from typing import Any, Dict, List, Optional, Tuple, Union
+
 from .client import Client
 from .defaults import DEFAULT_INFERENCE_CONTRACT_ADDRESS, DEFAULT_RPC_URL
-from .types import HistoricalInputQuery, InferenceMode, LlmInferenceMode, LLM, TEE_LLM, SchedulerParams
-from . import llm
-from . import mltools
+from .types import LLM, TEE_LLM, HistoricalInputQuery, InferenceMode, LlmInferenceMode, SchedulerParams
+
+from . import llm, mltools
 
 _client = None
 
-def init(email: str,
-         password: str,
-         private_key: str,
-         rpc_url=DEFAULT_RPC_URL,
-         contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS):
+
+def new_client(
+    email: str, password: str, private_key: str, rpc_url=DEFAULT_RPC_URL, contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS
+) -> Client:
+    """
+    Creates a unique OpenGradient client instance with the given authentication and network settings.
+
+    Args:
+        email: User's email address for authentication
+        password: User's password for authentication
+        private_key: Ethereum private key for blockchain transactions
+        rpc_url: Optional RPC URL for the blockchain network, defaults to mainnet
+        contract_address: Optional inference contract address
+    """
+
+    return Client(email=email, password=password, private_key=private_key, rpc_url=rpc_url, contract_address=contract_address)
+
+
+def init(email: str, password: str, private_key: str, rpc_url=DEFAULT_RPC_URL, contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS):
     """Initialize the OpenGradient SDK with authentication and network settings.
 
     Args:
@@ -26,16 +41,11 @@ def init(email: str,
         contract_address: Optional inference contract address
     """
     global _client
-    
-    _client = Client(
-        private_key=private_key,
-        rpc_url=rpc_url,
-        email=email,
-        password=password,
-        contract_address=contract_address
-    )
+
+    _client = Client(private_key=private_key, rpc_url=rpc_url, email=email, password=password, contract_address=contract_address)
     return _client
 
+
 def upload(model_path, model_name, version):
     """Upload a model file to OpenGradient.
 
@@ -54,6 +64,7 @@ def upload(model_path, model_name, version):
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.upload(model_path, model_name, version)
 
+
 def create_model(model_name: str, model_desc: str, model_path: str = None):
     """Create a new model repository.
 
@@ -70,16 +81,17 @@ def create_model(model_name: str, model_desc: str, model_path: str = None):
     """
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    
+
     result = _client.create_model(model_name, model_desc)
-    
+
     if model_path:
         version = "0.01"
         upload_result = _client.upload(model_path, model_name, version)
         result["upload"] = upload_result
-    
+
     return result
 
+
 def create_version(model_name, notes=None, is_major=False):
     """Create a new version for an existing model.
 
@@ -98,6 +110,7 @@ def create_version(model_name, notes=None, is_major=False):
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.create_version(model_name, notes, is_major)
 
+
 def infer(model_cid, inference_mode, model_input, max_retries: Optional[int] = None):
     """Run inference on a model.
 
@@ -117,13 +130,16 @@ def infer(model_cid, inference_mode, model_input, max_retries: Optional[int] = N
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.infer(model_cid, inference_mode, model_input, max_retries=max_retries)
 
-def llm_completion(model_cid: LLM, 
-                  prompt: str, 
-                  inference_mode: str = LlmInferenceMode.VANILLA,
-                  max_tokens: int = 100, 
-                  stop_sequence: Optional[List[str]] = None, 
-                  temperature: float = 0.0,
-                  max_retries: Optional[int] = None) -> Tuple[str, str]:
+
+def llm_completion(
+    model_cid: LLM,
+    prompt: str,
+    inference_mode: str = LlmInferenceMode.VANILLA,
+    max_tokens: int = 100,
+    stop_sequence: Optional[List[str]] = None,
+    temperature: float = 0.0,
+    max_retries: Optional[int] = None,
+) -> Tuple[str, str]:
     """Generate text completion using an LLM.
 
     Args:
@@ -143,23 +159,28 @@ def llm_completion(model_cid: LLM,
     """
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.llm_completion(model_cid=model_cid, 
-                                inference_mode=inference_mode, 
-                                prompt=prompt,
-                                max_tokens=max_tokens, 
-                                stop_sequence=stop_sequence, 
-                                temperature=temperature,
-                                max_retries=max_retries)
-
-def llm_chat(model_cid: LLM,
-             messages: List[Dict],
-             inference_mode: str = LlmInferenceMode.VANILLA,
-             max_tokens: int = 100,
-             stop_sequence: Optional[List[str]] = None,
-             temperature: float = 0.0,
-             tools: Optional[List[Dict]] = None,
-             tool_choice: Optional[str] = None,
-             max_retries: Optional[int] = None) -> Tuple[str, str, Dict]:
+    return _client.llm_completion(
+        model_cid=model_cid,
+        inference_mode=inference_mode,
+        prompt=prompt,
+        max_tokens=max_tokens,
+        stop_sequence=stop_sequence,
+        temperature=temperature,
+        max_retries=max_retries,
+    )
+
+
+def llm_chat(
+    model_cid: LLM,
+    messages: List[Dict],
+    inference_mode: str = LlmInferenceMode.VANILLA,
+    max_tokens: int = 100,
+    stop_sequence: Optional[List[str]] = None,
+    temperature: float = 0.0,
+    tools: Optional[List[Dict]] = None,
+    tool_choice: Optional[str] = None,
+    max_retries: Optional[int] = None,
+) -> Tuple[str, str, Dict]:
     """Have a chat conversation with an LLM.
 
     Args:
@@ -181,15 +202,18 @@ def llm_chat(model_cid: LLM,
     """
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.llm_chat(model_cid=model_cid, 
-                          inference_mode=inference_mode, 
-                          messages=messages, 
-                          max_tokens=max_tokens, 
-                          stop_sequence=stop_sequence, 
-                          temperature=temperature, 
-                          tools=tools, 
-                          tool_choice=tool_choice,
-                          max_retries=max_retries)
+    return _client.llm_chat(
+        model_cid=model_cid,
+        inference_mode=inference_mode,
+        messages=messages,
+        max_tokens=max_tokens,
+        stop_sequence=stop_sequence,
+        temperature=temperature,
+        tools=tools,
+        tool_choice=tool_choice,
+        max_retries=max_retries,
+    )
+
 
 def login(email: str, password: str):
     """Login to OpenGradient.
@@ -208,6 +232,7 @@ def login(email: str, password: str):
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.login(email, password)
 
+
 def list_files(model_name: str, version: str) -> List[Dict]:
     """List files in a model repository version.
 
@@ -225,6 +250,7 @@ def list_files(model_name: str, version: str) -> List[Dict]:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.list_files(model_name, version)
 
+
 def generate_image(model: str, prompt: str, height: Optional[int] = None, width: Optional[int] = None) -> bytes:
     """Generate an image from a text prompt.
 
@@ -245,19 +271,20 @@ def generate_image(model: str, prompt: str, height: Optional[int] = None, width:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.generate_image(model, prompt, height=height, width=width)
 
+
 def new_workflow(
     model_cid: str,
     input_query: Union[Dict[str, Any], HistoricalInputQuery],
     input_tensor_name: str,
-    scheduler_params: Optional[Union[Dict[str, int], SchedulerParams]] = None
+    scheduler_params: Optional[Union[Dict[str, int], SchedulerParams]] = None,
 ) -> str:
     """
     Deploy a new workflow contract with the specified parameters.
-    
-    This function deploys a new workflow contract and optionally registers it with 
-    the scheduler for automated execution. If scheduler_params is not provided, 
+
+    This function deploys a new workflow contract and optionally registers it with
+    the scheduler for automated execution. If scheduler_params is not provided,
     the workflow will be deployed without automated execution scheduling.
-    
+
     Args:
         model_cid: IPFS CID of the model
         input_query: Dictionary or HistoricalInputQuery containing query parameters
@@ -268,40 +295,38 @@ def new_workflow(
                 - duration_hours: How long to run in hours (default: 2)
             - Or a SchedulerParams instance
             If not provided, the workflow will be deployed without scheduling.
-    
+
     Returns:
         str: Deployed contract address. If scheduler_params was provided, the workflow
              will be automatically executed according to the specified schedule.
     """
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init(...) first.")
-    
+
     # Convert scheduler_params if it's a dict, otherwise use as is
     scheduler = SchedulerParams.from_dict(scheduler_params) if isinstance(scheduler_params, dict) else scheduler_params
-    
+
     return _client.new_workflow(
-        model_cid=model_cid,
-        input_query=input_query,
-        input_tensor_name=input_tensor_name,
-        scheduler_params=scheduler
+        model_cid=model_cid, input_query=input_query, input_tensor_name=input_tensor_name, scheduler_params=scheduler
     )
 
+
 def read_workflow_result(contract_address: str) -> Dict[str, Union[str, Dict]]:
     """
     Reads the latest inference result from a deployed workflow contract.
-    
+
     This function retrieves the most recent output from a deployed model executor contract.
     It includes built-in retry logic to handle blockchain state delays.
-    
+
     Args:
         contract_address (str): Address of the deployed workflow contract
-            
+
     Returns:
         Dict[str, Union[str, Dict]]: A dictionary containing:
             - status: "success" or "error"
             - result: The model output data if successful
             - error: Error message if status is "error"
-            
+
     Raises:
         RuntimeError: If OpenGradient client is not initialized
     """
@@ -309,13 +334,14 @@ def read_workflow_result(contract_address: str) -> Dict[str, Union[str, Dict]]:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.read_workflow_result(contract_address)
 
+
 def run_workflow(contract_address: str) -> Dict[str, Union[str, Dict]]:
     """
     Executes the workflow by calling run() on the contract to pull latest data and perform inference.
-    
+
     Args:
         contract_address (str): Address of the deployed workflow contract
-        
+
     Returns:
         Dict[str, Union[str, Dict]]: Status of the run operation
     """
@@ -323,33 +349,34 @@ def run_workflow(contract_address: str) -> Dict[str, Union[str, Dict]]:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.run_workflow(contract_address)
 
+
 __all__ = [
-    'generate_image',
-    'list_files',
-    'login',
-    'llm_chat',
-    'llm_completion',
-    'infer',
-    'create_version',
-    'create_model',
-    'upload',
-    'init',
-    'LLM',
-    'TEE_LLM',
-    'new_workflow',
-    'read_workflow_result',
-    'run_workflow'
+    "generate_image",
+    "list_files",
+    "login",
+    "llm_chat",
+    "llm_completion",
+    "infer",
+    "create_version",
+    "create_model",
+    "upload",
+    "init",
+    "LLM",
+    "TEE_LLM",
+    "new_workflow",
+    "read_workflow_result",
+    "run_workflow",
 ]
 
 __pdoc__ = {
-    'account': False,
-    'cli': False,
-    'client': False,
-    'defaults': False,
-    'exceptions': False,
-    'llm': True,
-    'mltools': True,
-    'proto': False,
-    'types': True,
-    'utils': False
-}
+    "account": False,
+    "cli": False,
+    "client": False,
+    "defaults": False,
+    "exceptions": False,
+    "llm": True,
+    "mltools": True,
+    "proto": False,
+    "types": False,
+    "utils": False,
+}

{opengradient-0.3.24 → opengradient-0.3.25}/src/opengradient/account.py

@@ -5,7 +5,7 @@ from collections import namedtuple
 
 from eth_account import Account
 
-EthAccount = namedtuple('EthAccount', ['address', 'private_key'])
+EthAccount = namedtuple("EthAccount", ["address", "private_key"])
 
 
 def generate_eth_account() -> EthAccount:
@@ -20,19 +20,21 @@ def generate_eth_account() -> EthAccount:
 
     return EthAccount(address=public_key, private_key=private_key)
 
+
 def _get_user_random_seed():
     print("Please type a random string of characters (the longer and more random, the better):")
     print("> ", end="")  # Add a '>' prompt on a new line
     return input().encode()
 
+
 def _generate_secure_private_key(user_input):
     # Combine multiple sources of entropy
     system_random = secrets.token_bytes(32)
     os_urandom = os.urandom(32)
     timestamp = str(secrets.randbits(256)).encode()
-    
+
     # Add user input to the entropy sources
     combined = system_random + os_urandom + timestamp + user_input
-    
+
     # Hash the combined entropy
-    return hashlib.sha256(combined).hexdigest()
+    return hashlib.sha256(combined).hexdigest()