opengradient 0.2.8__tar.gz → 0.3.0__tar.gz

{opengradient-0.2.8/src/opengradient.egg-info → opengradient-0.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: opengradient
-Version: 0.2.8
-Summary: A Python SDK for OpenGradient inference services
+Version: 0.3.0
+Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License
         
@@ -135,9 +135,9 @@ Requires-Dist: websockets==13.1
 Requires-Dist: xattr==1.1.0
 Requires-Dist: yarl==1.13.1
 
-# OpenGradient Python SDK
+# OpenGradient SDK
 
-Python SDK for OpenGradient inference services.
+Python SDK for OpenGradient decentralized model management & inference services.
 
 ## Installation
 ```python
@@ -147,41 +147,47 @@ pip install opengradient
 ## Quick Start
 ```python
 import opengradient as og
-og.init(private_key="x", rpc_url="y", contract_address="z")
+og.init(email="<email>", password="<password>")
 ```
 
-### Sign in with Email
+### Create a Model
 ```python
-og.login(email="you@opengradient.ai", password="xyz")
+og.create_model(model_name="<model_name>", model_desc="<model_description>")
 ```
 
-### Create a Model
+### Create a Model (with file upload)
 ```python
-og.create_model(model_name="test-network-model", model_desc="testing upload to sdk")
+og.create_model(model_name="<model_name>", model_desc="<model_description>", model_path="<model_path>")
 ```
 
 ### Create a Version of a Model
 ```python
-og.create_version(model_name="test-network-model", notes="test notes")
+og.create_version(model_name="<model_name>", notes="<model_notes>")
 ```
 
 ### Upload Files to a Model
 ```python
-og.upload(model_path="local_path_to_your_model.onnx", model_name="test-network-model", version="0.01")
+og.upload(model_path="<model_path>", model_name="<model_name>", version="<version>")
 ```
 
-### Run Inference
+### List Files of a Model Version
 ```python
-inference_mode = og.InferenceMode.VANILLA
-inference_cid = og.infer(model_cid, model_inputs, inference_mode)
+og.list_files(model_name="<model_name>", version="<version>")
 ```
 
+### Run Inference
 ```python
-og.infer(model_id, inference_mode, model_input)
+inference_mode = og.InferenceMode.VANILLA
+og.infer(model_cid, model_inputs, inference_mode)
 ```
 
 ## Using the CLI
 
+```bash
+export OPENGRADIENT_EMAIL="<email>"
+export OPENGRADIENT_PASSWORD="<password>"
+```
+
 #### Creating a Model
 ```bash
 opengradient create_model "<model_name>" "<description>" 
@@ -195,7 +201,12 @@ opengradient create_model "<model_name>" "<description>"
 
 #### Upload a File
 ```bash
-opengradient upload "path/to/model.onnx" "<model_name>" "<version>" 
+opengradient upload "<model_path>" "<model_name>" "<version>" 
+```
+
+#### List Files of a Model Version
+```bash
+opengradient list_files "<model_name>" "<version>"
 ```
 
 ####  CLI infer using string 

{opengradient-0.2.8 → opengradient-0.3.0}/README.md

@@ -1,6 +1,6 @@
-# OpenGradient Python SDK
+# OpenGradient SDK
 
-Python SDK for OpenGradient inference services.
+Python SDK for OpenGradient decentralized model management & inference services.
 
 ## Installation
 ```python
@@ -10,41 +10,47 @@ pip install opengradient
 ## Quick Start
 ```python
 import opengradient as og
-og.init(private_key="x", rpc_url="y", contract_address="z")
+og.init(email="<email>", password="<password>")
 ```
 
-### Sign in with Email
+### Create a Model
 ```python
-og.login(email="you@opengradient.ai", password="xyz")
+og.create_model(model_name="<model_name>", model_desc="<model_description>")
 ```
 
-### Create a Model
+### Create a Model (with file upload)
 ```python
-og.create_model(model_name="test-network-model", model_desc="testing upload to sdk")
+og.create_model(model_name="<model_name>", model_desc="<model_description>", model_path="<model_path>")
 ```
 
 ### Create a Version of a Model
 ```python
-og.create_version(model_name="test-network-model", notes="test notes")
+og.create_version(model_name="<model_name>", notes="<model_notes>")
 ```
 
 ### Upload Files to a Model
 ```python
-og.upload(model_path="local_path_to_your_model.onnx", model_name="test-network-model", version="0.01")
+og.upload(model_path="<model_path>", model_name="<model_name>", version="<version>")
 ```
 
-### Run Inference
+### List Files of a Model Version
 ```python
-inference_mode = og.InferenceMode.VANILLA
-inference_cid = og.infer(model_cid, model_inputs, inference_mode)
+og.list_files(model_name="<model_name>", version="<version>")
 ```
 
+### Run Inference
 ```python
-og.infer(model_id, inference_mode, model_input)
+inference_mode = og.InferenceMode.VANILLA
+og.infer(model_cid, model_inputs, inference_mode)
 ```
 
 ## Using the CLI
 
+```bash
+export OPENGRADIENT_EMAIL="<email>"
+export OPENGRADIENT_PASSWORD="<password>"
+```
+
 #### Creating a Model
 ```bash
 opengradient create_model "<model_name>" "<description>" 
@@ -58,7 +64,12 @@ opengradient create_model "<model_name>" "<description>"
 
 #### Upload a File
 ```bash
-opengradient upload "path/to/model.onnx" "<model_name>" "<version>" 
+opengradient upload "<model_path>" "<model_name>" "<version>" 
+```
+
+#### List Files of a Model Version
+```bash
+opengradient list_files "<model_name>" "<version>"
 ```
 
 ####  CLI infer using string 

{opengradient-0.2.8 → opengradient-0.3.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opengradient"
-version = "0.2.8"
-description = "A Python SDK for OpenGradient inference services"
+version = "0.3.0"
+description = "Python SDK for OpenGradient decentralized model management & inference services"
 authors = [{name = "OpenGradient", email = "oliver@opengradient.ai"}]
 license = {file = "LICENSE"}
 readme = "README.md"

{opengradient-0.2.8 → opengradient-0.3.0}/src/opengradient/__init__.py

@@ -1,16 +1,16 @@
 from .client import Client
 from .defaults import *
 from .types import InferenceMode
-
-__version__ = "0.2.8"
+from typing import List, Dict
+__version__ = "0.3.0"
 
 _client = None
 
-def init(private_key=DEFAULT_PRIVATE_KEY,
+def init(email: str,
+         password: str,
+         private_key=DEFAULT_PRIVATE_KEY,
          rpc_url=DEFAULT_RPC_URL,
-         contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS,
-         email=DEFAULT_HUB_EMAIL,
-         password=DEFAULT_HUB_PASSWORD):
+         contract_address=DEFAULT_INFERENCE_CONTRACT_ADDRESS):
     global _client
     _client = Client(private_key=private_key, rpc_url=rpc_url, contract_address=contract_address, email=email, password=password)
 
@@ -19,10 +19,18 @@ 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, model_desc):
+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.")
-    return _client.create_model(model_name, model_desc)
+    
+    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):
     if _client is None:
@@ -37,4 +45,9 @@ def infer(model_cid, inference_mode, model_input):
 def login(email: str, password: str):
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.login(email, password)
+    return _client.login(email, password)
+
+def list_files(model_name: str, version: str) -> List[Dict]:
+    if _client is None:
+        raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
+    return _client.list_files(model_name, version)

opengradient-0.3.0/src/opengradient/abi/llm.abi

@@ -0,0 +1 @@
+[{"anonymous":false,"inputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"indexed":false,"internalType":"struct ModelOutput","name":"output","type":"tuple"}],"name":"InferenceResult","type":"event"},{"anonymous":false,"inputs":[{"components":[{"internalType":"string","name":"answer","type":"string"}],"indexed":false,"internalType":"struct LlmResponse","name":"response","type":"tuple"}],"name":"LLMResult","type":"event"},{"inputs":[{"internalType":"string","name":"modelId","type":"string"},{"internalType":"enum ModelInferenceMode","name":"inferenceMode","type":"uint8"},{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"}],"internalType":"struct ModelInput","name":"modelInput","type":"tuple"}],"name":"run","outputs":[{"components":[{"components":[{"internalType":"string","name":"name","type":"string"},{"components":[{"internalType":"int128","name":"value","type":"int128"},{"internalType":"int128","name":"decimals","type":"int128"}],"internalType":"struct TensorLib.Number[]","name":"values","type":"tuple[]"},{"internalType":"uint32[]","name":"shape","type":"uint32[]"}],"internalType":"struct TensorLib.MultiDimensionalNumberTensor[]","name":"numbers","type":"tuple[]"},{"components":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string[]","name":"values","type":"string[]"}],"internalType":"struct TensorLib.StringTensor[]","name":"strings","type":"tuple[]"},{"internalType":"bool","name":"is_simulation_result","type":"bool"}],"internalType":"struct ModelOutput","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"enum LlmInferenceMode","name":"mode","type":"uint8"},{"internalType":"string","name":"modelCID","type":"string"},{"internalType":"string","name":"prompt","type":"string"},{"internalType":"uint32","name":"max_tokens","type":"uint32"},{"internalType":"string[]","name":"stop_sequence","type":"string[]"},{"internalType":"uint32","name":"temperature","type":"uint32"}],"internalType":"struct LlmInferenceRequest","name":"request","type":"tuple"}],"name":"runLLM","outputs":[{"components":[{"internalType":"string","name":"answer","type":"string"}],"internalType":"struct LlmResponse","name":"","type":"tuple"}],"stateMutability":"nonpayable","type":"function"}]

opengradient-0.3.0/src/opengradient/account.py

@@ -0,0 +1,37 @@
+from eth_account import Account
+import secrets
+from collections import namedtuple
+import os
+import hashlib
+
+EthAccount = namedtuple('EthAccount', ['address', 'private_key'])
+
+
+def generate_eth_account() -> EthAccount:
+    user_seed = _get_user_random_seed()
+    private_key = _generate_secure_private_key(user_seed)
+
+    # derive account
+    account = Account.from_key(private_key)
+
+    # get the public key (address)
+    public_key = account.address
+
+    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()

opengradient-0.3.0/src/opengradient/cli.py

@@ -0,0 +1,390 @@
+import click
+import opengradient
+import json
+import ast
+from pathlib import Path
+import logging
+from pprint import pformat
+import webbrowser
+import sys
+
+from .client import Client
+from .defaults import *
+from .types import InferenceMode
+from .account import EthAccount, generate_eth_account
+
+OG_CONFIG_FILE = Path.home() / '.opengradient_config.json'
+
+
+def load_og_config():
+    if OG_CONFIG_FILE.exists():
+        with OG_CONFIG_FILE.open('r') as f:
+            return json.load(f)
+    return {}
+
+def save_og_config(ctx):
+    with OG_CONFIG_FILE.open('w') as f:
+        json.dump(ctx.obj, f)
+
+# Convert string to dictionary click parameter typing
+class DictParamType(click.ParamType):
+    name = "dictionary"
+
+    def convert(self, value, param, ctx):
+        if isinstance(value, dict):
+            return value
+        try:
+            # First, try to parse as JSON
+            return json.loads(value)
+        except json.JSONDecodeError:
+            # If JSON parsing fails, try to evaluate as a Python literal
+            try:
+                # ast.literal_eval is safer than eval as it only parses Python literals
+                result = ast.literal_eval(value)
+                if not isinstance(result, dict):
+                    self.fail(f"'{value}' is not a valid dictionary", param, ctx)
+                return result
+            except (ValueError, SyntaxError):
+                self.fail(f"'{value}' is not a valid dictionary", param, ctx)
+
+Dict = DictParamType()
+
+# Support inference modes
+InferenceModes = {
+    "VANILLA": InferenceMode.VANILLA,
+    "ZKML": InferenceMode.ZKML,
+    "TEE": InferenceMode.TEE,
+}
+
+
+def initialize_config(ctx):
+    """Interactively initialize OpenGradient config"""
+    if ctx.obj:  # Check if config data already exists
+        click.echo("A config already exists. Please run 'opengradient config clear' first if you want to reinitialize.")
+        click.echo("You can view your current config with 'opengradient config show'.")
+
+    click.echo("Initializing OpenGradient config...")
+    click.secho(f"Config will be stored in: {OG_CONFIG_FILE}", fg='cyan')
+
+    # Check if user has an existing account
+    has_account = click.confirm("Do you already have an OpenGradient account?", default=True)
+
+    if not has_account:
+        eth_account = create_account_impl()
+        if eth_account is None:
+            click.echo("Account creation cancelled. Config initialization aborted.")
+            return
+        ctx.obj['private_key'] = eth_account.private_key
+    else:
+        ctx.obj['private_key'] = click.prompt("Enter your OpenGradient private key", type=str)
+
+    # Make email and password optional
+    email = click.prompt("Enter your OpenGradient Hub email address (optional, press Enter to skip)", 
+                         type=str, default='', show_default=False)
+    ctx.obj['email'] = email if email else None
+    password = click.prompt("Enter your OpenGradient Hub password (optional, press Enter to skip)", 
+                            type=str, hide_input=True, default='', show_default=False)
+    ctx.obj['password'] = password if password else None
+
+    ctx.obj['rpc_url'] = DEFAULT_RPC_URL
+    ctx.obj['contract_address'] = DEFAULT_INFERENCE_CONTRACT_ADDRESS
+    
+    save_og_config(ctx)
+    click.echo("Config has been saved.")
+    click.secho("You can run 'opengradient config show' to see configs.", fg='green')
+
+
+@click.group()
+@click.pass_context
+def cli(ctx):
+    """CLI for OpenGradient SDK. Visit https://docs.opengradient.ai/developers/python_sdk/ for more documentation."""
+    # Load existing config 
+    ctx.obj = load_og_config()
+
+    no_client_commands = ['config', 'create-account', 'version']
+
+    # Only create client if this is not a config management command
+    if ctx.invoked_subcommand in no_client_commands:
+        return
+
+    if all(key in ctx.obj for key in ['private_key', 'rpc_url', 'contract_address']):
+        try:
+            ctx.obj['client'] = Client(private_key=ctx.obj['private_key'], 
+                                        rpc_url=ctx.obj['rpc_url'],
+                                        contract_address=ctx.obj['contract_address'],
+                                        email=ctx.obj.get('email'),
+                                        password=ctx.obj.get('password'))
+        except Exception as e:
+            click.echo(f"Failed to create OpenGradient client: {str(e)}")
+            ctx.exit(1)
+    else:
+        click.echo("Insufficient information to create client. Some commands may not be available.")
+        click.echo("Please run 'opengradient config clear' and/or 'opengradient config init' and to reinitialize your configs.")
+        ctx.exit(1)
+
+
+@cli.group()
+def config():
+    """Manage your OpenGradient configuration (credentials etc)"""
+    pass
+
+
+@config.command()
+@click.pass_context
+def init(ctx):
+    """Initialize or reinitialize the OpenGradient config"""
+    initialize_config(ctx)
+
+
+@config.command()
+@click.pass_context
+def show(ctx):
+    """Display current config information"""
+    click.secho(f"Config file location: {OG_CONFIG_FILE}", fg='cyan')
+
+    if not ctx.obj:
+        click.echo("Config is empty. Run 'opengradient config init' to initialize it.")
+        return
+
+    click.echo("Current config:")
+    for key, value in ctx.obj.items():
+        if key != 'client':  # Don't display the client object
+            if key == 'password' and value is not None:
+                click.echo(f"{key}: {'*' * len(value)}")  # Mask the password
+            elif value is None:
+                click.echo(f"{key}: Not set")
+            else:
+                click.echo(f"{key}: {value}") 
+
+
+@config.command()
+@click.pass_context
+def clear(ctx):
+    """Clear all saved configs"""
+    if not ctx.obj:
+        click.echo("No configs to clear.")
+        return
+
+    if click.confirm("Are you sure you want to clear all configs? This action cannot be undone.", abort=True):
+        ctx.obj.clear()
+        save_og_config(ctx)
+        click.echo("Configs cleared.")
+    else:
+        click.echo("Config clear cancelled.")
+
+
+@cli.command()
+@click.option('--repo', '-r', '--name', 'repo_name', required=True, help='Name of the new model repository')
+@click.option('--description', '-d', required=True, help='Description of the model')
+@click.pass_obj
+def create_model_repo(obj, repo_name: str, description: str):
+    """
+    Create a new model repository.
+
+    This command creates a new model repository with the specified name and description.
+    The repository name should be unique within your account.
+
+    Example usage:
+
+    \b
+    opengradient create-model-repo --name "my_new_model" --description "A new model for XYZ task"
+    opengradient create-model-repo -n "my_new_model" -d "A new model for XYZ task"
+    """
+    client: Client = obj['client']
+
+    try:
+        result = client.create_model(repo_name, description)
+        click.echo(f"Model repository created successfully: {result}")
+    except Exception as e:
+        click.echo(f"Error creating model: {str(e)}")
+
+
+@cli.command()
+@click.option('--repo', '-r', 'repo_name', required=True, help='Name of the existing model repository')
+@click.option('--notes', '-n', help='Version notes (optional)')
+@click.option('--major', '-m', is_flag=True, default=False, help='Flag to indicate a major version update')
+@click.pass_obj
+def create_version(obj, repo_name: str, notes: str, major: bool):
+    """Create a new version in an existing model repository.
+
+    This command creates a new version for the specified model repository. 
+    You can optionally provide version notes and indicate if it's a major version update.
+
+    Example usage:
+
+    \b
+    opengradient create-version --repo my_model_repo --notes "Added new feature X" --major
+    opengradient create-version -r my_model_repo -n "Bug fixes"
+    """
+    client: Client = obj['client']
+
+    try:
+        result = client.create_version(repo_name, notes, major)
+        click.echo(f"New version created successfully: {result}")
+    except Exception as e:
+        click.echo(f"Error creating version: {str(e)}")
+
+
+@cli.command()
+@click.argument('file_path', type=click.Path(exists=True, file_okay=True, dir_okay=False, readable=True, path_type=Path),
+                metavar='FILE_PATH')
+@click.option('--repo', '-r', 'repo_name', required=True, help='Name of the model repository')
+@click.option('--version', '-v', required=True, help='Version of the model (e.g., "0.01")')
+@click.pass_obj
+def upload_file(obj, file_path: Path, repo_name: str, version: str):
+    """
+    Upload a file to an existing model repository and version.
+
+    FILE_PATH: Path to the file you want to upload (e.g., model.onnx)
+
+    Example usage:
+
+    \b
+    opengradient upload-file path/to/model.onnx --repo my_model_repo --version 0.01
+    opengradient upload-file path/to/model.onnx -r my_model_repo -v 0.01
+    """
+    client: Client = obj['client']
+
+    try:
+        result = client.upload(file_path, repo_name, version)
+        click.echo(f"File uploaded successfully: {result}")
+    except Exception as e:
+        click.echo(f"Error uploading model: {str(e)}")
+
+
+@cli.command()
+@click.option('--model', '-m', 'model_cid', required=True, help='CID of the model to run inference on')
+@click.option('--mode', 'inference_mode', type=click.Choice(InferenceModes.keys()), default="VANILLA", 
+              help='Inference mode (default: VANILLA)')
+@click.option('--input', '-d', 'input_data', type=Dict, help='Input data for inference as a JSON string')
+@click.option('--input-file', '-f', 
+              type=click.Path(exists=True, file_okay=True, dir_okay=False, readable=True, path_type=Path),
+              help="JSON file containing input data for inference")
+@click.pass_context
+def infer(ctx, model_cid: str, inference_mode: str, input_data, input_file: Path):
+    """
+    Run inference on a model.
+
+    This command runs inference on the specified model using the provided input data.
+    You must provide either --input or --input-file, but not both.
+
+    Example usage:
+
+    \b
+    opengradient infer --model Qm... --mode VANILLA --input '{"key": "value"}'
+    opengradient infer -m Qm... -i ZKML -f input_data.json
+    """
+    client: Client = ctx.obj['client']
+
+    try:
+        if not input_data and not input_file:
+            click.echo("Must specify either input_data or input_file")
+            ctx.exit(1)
+            return
+        
+        if input_data and input_file:
+            click.echo("Cannot have both input_data and input_file")
+            ctx.exit(1)
+            return
+        
+        if input_data:
+            model_input = input_data
+
+        if input_file:
+            with input_file.open('r') as file:
+                model_input = json.load(file)
+            
+        # Parse input data from string to dict
+        click.echo(f"Running {inference_mode} inference for model \"{model_cid}\"\n")
+        tx_hash, model_output = client.infer(model_cid=model_cid, inference_mode=InferenceModes[inference_mode], model_input=model_input)
+
+        click.secho("Success!", fg="green")
+        click.echo(f"Transaction hash: {tx_hash}")
+        click.echo(f"Inference result:\n{pformat(model_output, indent=2, width=120)}")
+    except json.JSONDecodeError as e:
+        click.echo(f"Error decoding JSON: {e}", err=True)
+        click.echo(f"Error occurred on line {e.lineno}, column {e.colno}", err=True)
+    except Exception as e:
+        click.echo(f"Error running inference: {str(e)}")
+
+
+@cli.command()
+def create_account():
+    """Create a new test account for OpenGradient inference and model management"""
+    create_account_impl()
+
+
+def create_account_impl() -> EthAccount:
+    click.echo("\n" + "=" * 50)
+    click.echo("OpenGradient Account Creation Wizard".center(50))
+    click.echo("=" * 50 + "\n")
+
+    click.echo("\n" + "-" * 50)
+    click.echo("Step 1: Create Account on OpenGradient Hub")
+    click.echo("-" * 50)
+
+    click.echo(f"Please create an account on the OpenGradient Hub")
+    webbrowser.open(DEFAULT_HUB_SIGNUP_URL, new=2)
+    click.confirm("Have you successfully created your account on the OpenGradient Hub?", abort=True)
+
+    click.echo("\n" + "-" * 50)
+    click.echo("Step 2: Generate Ethereum Account")
+    click.echo("-" * 50)
+    eth_account = generate_eth_account()
+    click.echo(f"Generated OpenGradient chain account with address: {eth_account.address}")
+
+    click.echo("\n" + "-" * 50)
+    click.echo("Step 3: Fund Your Account")
+    click.echo("-" * 50)
+    click.echo(f"Please fund your account clicking 'Request' on the Faucet website")
+    webbrowser.open(DEFAULT_OG_FAUCET_URL + eth_account.address, new=2)
+    click.confirm("Have you successfully funded your account using the Faucet?", abort=True)
+
+    click.echo("\n" + "=" * 50)
+    click.echo("Account Creation Complete!".center(50))
+    click.echo("=" * 50)
+    click.echo("\nYour OpenGradient account has been successfully created and funded.")
+    click.secho(f"Address: {eth_account.address}", fg='green')
+    click.secho(f"Private Key: {eth_account.private_key}", fg='green')
+    click.secho("\nPlease save this information for your records.\n", fg='cyan')
+
+    return eth_account
+
+
+@cli.command()
+def version():
+    """Return version of OpenGradient CLI"""
+    click.echo(f"OpenGradient CLI version: {opengradient.__version__}")
+
+
+@cli.command()
+@click.option('--repo', '-r', 'repo_name', required=True, help='Name of the model repository')
+@click.option('--version', '-v', required=True, help='Version of the model (e.g., "0.01")')
+@click.pass_obj
+def list_files(client: Client, repo_name: str, version: str):
+    """
+    List files for a specific version of a model repository.
+
+    This command lists all files associated with the specified model repository and version.
+
+    Example usage:
+
+    \b
+    opengradient list-files --repo my_model_repo --version 0.01
+    opengradient list-files -r my_model_repo -v 0.01
+    """
+    try:
+        files = client.list_files(repo_name, version)
+        if files:
+            click.echo(f"Files for {repo_name} version {version}:")
+            for file in files:
+                click.echo(f"  - {file['name']} (Size: {file['size']} bytes)")
+        else:
+            click.echo(f"No files found for {repo_name} version {version}")
+    except Exception as e:
+        click.echo(f"Error listing files: {str(e)}")
+
+
+if __name__ == '__main__':
+    logging.getLogger().setLevel(logging.WARN)
+    cli()

{opengradient-0.2.8 → opengradient-0.3.0}/src/opengradient/client.py

@@ -11,8 +11,6 @@ from typing import Dict, Tuple, Union, List
 from web3.exceptions import ContractLogicError
 import firebase
 
-logging.basicConfig(level=logging.INFO)
-
 class Client:
     FIREBASE_CONFIG = {
         "apiKey": "AIzaSyDUVckVtfl-hiteBzPopy1pDD8Uvfncs7w",
@@ -23,7 +21,7 @@ class Client:
         "databaseURL": ""
     }
     
-    def __init__(self, private_key: str, rpc_url: str, contract_address: str, email: str = "test@test.com", password: str = "Test-123"):
+    def __init__(self, private_key: str, rpc_url: str, contract_address: str, email: str, password: str):
         """
         Initialize the Client with private key, RPC URL, and contract address.
 
@@ -43,6 +41,8 @@ class Client:
         self.firebase_app = firebase.initialize_app(self.FIREBASE_CONFIG)
         self.auth = self.firebase_app.auth()
         self.user = None
+        self.email = email
+        self.password = password
         
         logging.debug("Initialized client with parameters:\n"
                       "private key: %s\n"
@@ -55,7 +55,8 @@ class Client:
             inference_abi = json.load(abi_file)
         self.abi = inference_abi
 
-        self.login(email, password)
+        if email is not None:
+            self.login(email, password)
 
     def _initialize_web3(self):
         """
@@ -279,7 +280,6 @@ class Client:
             logging.error(f"Request exception during upload: {str(e)}")
             if hasattr(e, 'response') and e.response is not None:
                 logging.error(f"Response status code: {e.response.status_code}")
-                logging.error(f"Response headers: {e.response.headers}")
                 logging.error(f"Response content: {e.response.text[:1000]}...")  # Log first 1000 characters
             raise OpenGradientError(f"Upload failed due to request exception: {str(e)}", 
                                     status_code=e.response.status_code if hasattr(e, 'response') else None)
@@ -408,4 +408,49 @@ class Client:
             return self.user
         except Exception as e:
             logging.error(f"Authentication failed: {str(e)}")
-            raise
+            raise
+
+    def list_files(self, model_name: str, version: str) -> List[Dict]:
+        """
+        List files for a specific version of a model.
+
+        Args:
+            model_name (str): The unique identifier for the model.
+            version (str): The version identifier for the model.
+
+        Returns:
+            List[Dict]: A list of dictionaries containing file information.
+
+        Raises:
+            OpenGradientError: If the file listing fails.
+        """
+        if not self.user:
+            raise ValueError("User not authenticated")
+
+        url = f"https://api.opengradient.ai/api/v0/models/{model_name}/versions/{version}/files"
+        headers = {
+            'Authorization': f'Bearer {self.user["idToken"]}'
+        }
+
+        logging.debug(f"List Files URL: {url}")
+        logging.debug(f"Headers: {headers}")
+
+        try:
+            response = requests.get(url, headers=headers)
+            response.raise_for_status()
+
+            json_response = response.json()
+            logging.info(f"File listing successful. Number of files: {len(json_response)}")
+            
+            return json_response
+
+        except requests.RequestException as e:
+            logging.error(f"File listing failed: {str(e)}")
+            if hasattr(e, 'response') and e.response is not None:
+                logging.error(f"Response status code: {e.response.status_code}")
+                logging.error(f"Response content: {e.response.text[:1000]}...")  # Log first 1000 characters
+            raise OpenGradientError(f"File listing failed: {str(e)}", 
+                                    status_code=e.response.status_code if hasattr(e, 'response') else None)
+        except Exception as e:
+            logging.error(f"Unexpected error during file listing: {str(e)}", exc_info=True)
+            raise OpenGradientError(f"Unexpected error during file listing: {str(e)}")

{opengradient-0.2.8 → opengradient-0.3.0}/src/opengradient/defaults.py

@@ -2,6 +2,6 @@
 # Default variables
 DEFAULT_PRIVATE_KEY="cd09980ef6e280afc3900d2d6801f9e9c5d858a5deaeeab74a65643f5ff1a4c1"
 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="0x75D0266DAb643417e9FFD828A1A31C1E039a966c"
-DEFAULT_HUB_EMAIL="test@test.com"
-DEFAULT_HUB_PASSWORD="Test-123"

{opengradient-0.2.8 → opengradient-0.3.0/src/opengradient.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: opengradient
-Version: 0.2.8
-Summary: A Python SDK for OpenGradient inference services
+Version: 0.3.0
+Summary: Python SDK for OpenGradient decentralized model management & inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License
         
@@ -135,9 +135,9 @@ Requires-Dist: websockets==13.1
 Requires-Dist: xattr==1.1.0
 Requires-Dist: yarl==1.13.1
 
-# OpenGradient Python SDK
+# OpenGradient SDK
 
-Python SDK for OpenGradient inference services.
+Python SDK for OpenGradient decentralized model management & inference services.
 
 ## Installation
 ```python
@@ -147,41 +147,47 @@ pip install opengradient
 ## Quick Start
 ```python
 import opengradient as og
-og.init(private_key="x", rpc_url="y", contract_address="z")
+og.init(email="<email>", password="<password>")
 ```
 
-### Sign in with Email
+### Create a Model
 ```python
-og.login(email="you@opengradient.ai", password="xyz")
+og.create_model(model_name="<model_name>", model_desc="<model_description>")
 ```
 
-### Create a Model
+### Create a Model (with file upload)
 ```python
-og.create_model(model_name="test-network-model", model_desc="testing upload to sdk")
+og.create_model(model_name="<model_name>", model_desc="<model_description>", model_path="<model_path>")
 ```
 
 ### Create a Version of a Model
 ```python
-og.create_version(model_name="test-network-model", notes="test notes")
+og.create_version(model_name="<model_name>", notes="<model_notes>")
 ```
 
 ### Upload Files to a Model
 ```python
-og.upload(model_path="local_path_to_your_model.onnx", model_name="test-network-model", version="0.01")
+og.upload(model_path="<model_path>", model_name="<model_name>", version="<version>")
 ```
 
-### Run Inference
+### List Files of a Model Version
 ```python
-inference_mode = og.InferenceMode.VANILLA
-inference_cid = og.infer(model_cid, model_inputs, inference_mode)
+og.list_files(model_name="<model_name>", version="<version>")
 ```
 
+### Run Inference
 ```python
-og.infer(model_id, inference_mode, model_input)
+inference_mode = og.InferenceMode.VANILLA
+og.infer(model_cid, model_inputs, inference_mode)
 ```
 
 ## Using the CLI
 
+```bash
+export OPENGRADIENT_EMAIL="<email>"
+export OPENGRADIENT_PASSWORD="<password>"
+```
+
 #### Creating a Model
 ```bash
 opengradient create_model "<model_name>" "<description>" 
@@ -195,7 +201,12 @@ opengradient create_model "<model_name>" "<description>"
 
 #### Upload a File
 ```bash
-opengradient upload "path/to/model.onnx" "<model_name>" "<version>" 
+opengradient upload "<model_path>" "<model_name>" "<version>" 
+```
+
+#### List Files of a Model Version
+```bash
+opengradient list_files "<model_name>" "<version>"
 ```
 
 ####  CLI infer using string 

{opengradient-0.2.8 → opengradient-0.3.0}/src/opengradient.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 src/opengradient/__init__.py
+src/opengradient/account.py
 src/opengradient/cli.py
 src/opengradient/client.py
 src/opengradient/defaults.py
@@ -15,6 +16,4 @@ src/opengradient.egg-info/entry_points.txt
 src/opengradient.egg-info/requires.txt
 src/opengradient.egg-info/top_level.txt
 src/opengradient/abi/inference.abi
-tests/test_api.py
-tests/test_exceptions.py
-tests/test_integration.py
+src/opengradient/abi/llm.abi

opengradient-0.2.8/src/opengradient/cli.py

@@ -1,195 +0,0 @@
-import click
-import os
-import opengradient
-import json
-import ast
-from pathlib import Path
-from .client import Client
-from .defaults import *
-from .types import InferenceMode, ModelInput
-
-# Environment variable names
-PRIVATE_KEY_ENV = 'OPENGRADIENT_PRIVATE_KEY'
-RPC_URL_ENV = 'OPENGRADIENT_RPC_URL'
-CONTRACT_ADDRESS_ENV = 'OPENGRADIENT_CONTRACT_ADDRESS'
-EMAIL_ENV = 'OPENGRADIENT_EMAIL'
-PASSWORD_ENV = 'OPENGRADIENT_PASSWORD'
-
-# Convert string to dictionary click parameter typing
-class DictParamType(click.ParamType):
-    name = "dictionary"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, dict):
-            return value
-        try:
-            # First, try to parse as JSON
-            return json.loads(value)
-        except json.JSONDecodeError:
-            # If JSON parsing fails, try to evaluate as a Python literal
-            try:
-                # ast.literal_eval is safer than eval as it only parses Python literals
-                result = ast.literal_eval(value)
-                if not isinstance(result, dict):
-                    self.fail(f"'{value}' is not a valid dictionary", param, ctx)
-                return result
-            except (ValueError, SyntaxError):
-                self.fail(f"'{value}' is not a valid dictionary", param, ctx)
-
-Dict = DictParamType()
-
-# Support inference modes
-InferenceModes = {
-    "VANILLA": InferenceMode.VANILLA,
-    "ZKML": InferenceMode.ZKML,
-    "TEE": InferenceMode.TEE,
-}
-
-# TODO (Kyle): Once we're farther into development, we should remove the defaults for these options
-@click.group()
-@click.option('--private_key', 
-              envvar=PRIVATE_KEY_ENV, 
-              help='Your OpenGradient private key', 
-              default=DEFAULT_PRIVATE_KEY)
-@click.option('--rpc_url', 
-              envvar=RPC_URL_ENV, 
-              help='OpenGradient RPC URL address', 
-              default=DEFAULT_RPC_URL)
-@click.option('--contract_address', 
-              envvar=CONTRACT_ADDRESS_ENV, 
-              help='OpenGradient inference contract address', 
-              default=DEFAULT_INFERENCE_CONTRACT_ADDRESS)
-@click.option('--email', 
-              envvar=EMAIL_ENV,
-              help='Your OpenGradient Hub email address -- not required for inference', 
-              default=DEFAULT_HUB_EMAIL)
-@click.option('--password', 
-              envvar=PASSWORD_ENV, 
-              help='Your OpenGradient Hub password -- not required for inference', 
-              default=DEFAULT_HUB_PASSWORD)
-@click.pass_context
-def cli(ctx, private_key, rpc_url, contract_address, email, password):
-    """CLI for OpenGradient SDK"""
-    if not private_key:
-        click.echo("Please provide a private key via flag or setting environment variable OPENGRADIENT_PRIVATE_KEY")
-    if not rpc_url:
-        click.echo("Please provide a RPC URL via flag or setting environment variable OPENGRADIENT_RPC_URL")
-    if not contract_address:
-        click.echo("Please provide a contract address via flag or setting environment variable OPENGRADIENT_CONTRACT_ADDRESS")
-    if not private_key or not rpc_url or not contract_address:
-        ctx.exit(1)
-        return
-
-    try:
-        ctx.obj = Client(private_key=private_key, 
-                         rpc_url=rpc_url,
-                         contract_address=contract_address,
-                         email=email,
-                         password=password)
-    except Exception as e:
-        click.echo(f"Failed to create OpenGradient client: {str(e)}")
-
-@cli.command()
-@click.pass_context
-def client_settings(ctx):
-    """Display OpenGradient client settings"""
-    client = ctx.obj
-    if not client:
-        click.echo("Client not initialized")
-        ctx.exit(1)
-        
-    click.echo("Settings for OpenGradient client:")
-    click.echo(f"\tPrivate key ({PRIVATE_KEY_ENV}): {client.private_key}")
-    click.echo(f"\tRPC URL ({RPC_URL_ENV}): {client.rpc_url}")
-    click.echo(f"\tContract address ({CONTRACT_ADDRESS_ENV}): {client.contract_address}")
-    if client.user:
-        click.echo(f"\tEmail ({EMAIL_ENV}): {client.user["email"]}")
-    else:
-        click.echo(f"\tEmail: not set")
-
-@cli.command()
-@click.argument('model_path', type=Path)
-@click.argument('model_id', type=str)
-@click.argument('version_id', type=str)
-@click.pass_obj
-def upload(client, model_path, model_id, version_id):
-    """Upload a model"""
-    try:
-        result = client.upload(model_path, model_id, version_id)
-        click.echo(f"Model uploaded successfully: {result}")
-    except Exception as e:
-        click.echo(f"Error uploading model: {str(e)}")
-
-@cli.command()
-@click.argument('model_name', type=str)
-@click.argument('model_desc', type=str)
-@click.pass_obj
-def create_model(client, model_name, model_desc):
-    """Create a new model"""
-    try:
-        result = client.create_model(model_name, model_desc)
-        click.echo(f"Model created successfully: {result}")
-    except Exception as e:
-        click.echo(f"Error creating model: {str(e)}")
-
-@cli.command()
-@click.argument('model_id', type=str)
-@click.option('--notes', type=str, default=None, help='Version notes')
-@click.option('--is-major', default=False, is_flag=True, help='Is this a major version')
-@click.pass_obj
-def create_version(client, model_id, notes, is_major):
-    """Create a new version of a model"""
-    try:
-        result = client.create_version(model_id, notes, is_major)
-        click.echo(f"Version created successfully: {result}")
-    except Exception as e:
-        click.echo(f"Error creating version: {str(e)}")
-
-@cli.command()
-@click.argument('model_cid', type=str)
-@click.argument('inference_mode', type=click.Choice(InferenceModes.keys()), default="VANILLA")
-@click.argument('input_data', type=Dict, required=False)
-@click.option('--input_file',
-              type=click.Path(exists=True, file_okay=True, dir_okay=False, readable=True, path_type=Path),
-              help="Optional file input for model inference -- must be JSON") 
-@click.pass_context
-def infer(ctx, model_cid, inference_mode, input_data, input_file):
-    """Run inference on a model"""
-    client = ctx.obj
-    try:
-        if not input_data and not input_file:
-            click.echo("Must specify either input_data or input_file")
-            ctx.exit(1)
-            return
-        
-        if input_data and input_file:
-            click.echo("Cannot have both input_data and input_file")
-            ctx.exit(1)
-            return
-        
-        if input_data:
-            model_input = input_data
-
-        if input_file:
-            with input_file.open('r') as file:
-                model_input = json.load(file)
-            
-        # Parse input data from string to dict
-        click.echo(f"Running {inference_mode} inference for {model_cid}...")
-        tx_hash, model_output = client.infer(model_cid=model_cid, inference_mode=InferenceModes[inference_mode], model_input=model_input)
-        click.secho("Success!", fg="green")
-        click.echo(f"\nTransaction Hash: \n{tx_hash}")
-        click.echo(f"\nInference result: \n{model_output}")
-    except json.JSONDecodeError as e:
-        click.echo(f"Error decoding JSON: {e}", err=True)
-        click.echo(f"Error occurred on line {e.lineno}, column {e.colno}", err=True)
-    except Exception as e:
-        click.echo(f"Error running inference: {str(e)}")
-
-
-@cli.command()
-def version():
-    click.echo(f"OpenGradient CLI version: {opengradient.__version__}")
-
-if __name__ == '__main__':
-    cli()

opengradient-0.2.8/tests/test_api.py

@@ -1,110 +0,0 @@
-import sys
-import os
-
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
-
-from src.client import Client
-from src.exceptions import FileNotFoundError, UploadError, InferenceError, ResultRetrievalError, AuthenticationError, RateLimitError, InvalidInputError
-
-import pytest
-from unittest.mock import patch, Mock, mock_open
-import requests
-import time
-
-@pytest.fixture
-def client():
-    return Client(api_key="test_api_key")
-
-def test_upload_success(client):
-    with patch('src.client.requests.request') as mock_request, \
-         patch('src.client.os.path.exists', return_value=True), \
-         patch('builtins.open', mock_open(read_data=b'fake_file_content')):
-        mock_response = Mock()
-        mock_response.json.return_value = {"model_cid": "test_cid"}
-        mock_response.raise_for_status.return_value = None
-        mock_request.return_value = mock_response
-
-        result = client.upload("test_model.onnx")
-        assert result == {"model_cid": "test_cid"}
-
-def test_upload_file_not_found(client):
-    with pytest.raises(FileNotFoundError):
-        client.upload("non_existent_file.onnx")
-
-def test_upload_authentication_error(client):
-    with patch('src.client.requests.request') as mock_request, \
-         patch('src.client.os.path.exists', return_value=True), \
-         patch('builtins.open', mock_open(read_data=b'fake_file_content')):
-        mock_response = Mock()
-        mock_response.raise_for_status.side_effect = requests.exceptions.HTTPError(response=Mock(status_code=401))
-        mock_request.return_value = mock_response
-
-        with pytest.raises(UploadError):
-            client.upload("test_model.onnx")
-
-# def test_infer_success(client):
-#     with patch('src.client.requests.request') as mock_request:
-#         mock_response = Mock()
-#         mock_response.json.return_value = {"inference_cid": "test_inference_cid"}
-#         mock_response.raise_for_status.return_value = None
-#         mock_request.return_value = mock_response
-
-#         result = client.infer("test_model_cid", {"input": [1, 2, 3]})
-#         assert result == {"inference_cid": "test_inference_cid"}
-
-# def test_get_results_not_ready(client):
-#     with patch('src.client.requests.request') as mock_request:
-#         mock_response = Mock()
-#         mock_response.json.return_value = {"status": "processing"}
-#         mock_response.raise_for_status.return_value = None
-#         mock_request.return_value = mock_response
-
-#         result, proof = client.get_results("test_inference_cid")
-#         assert result is None
-#         assert proof is None
-
-# def test_get_results_success(client):
-#     with patch('src.client.requests.request') as mock_request:
-#         mock_response = Mock()
-#         mock_response.json.return_value = {"status": "completed", "data": "test_result", "proof": "test_proof"}
-#         mock_response.raise_for_status.return_value = None
-#         mock_request.return_value = mock_response
-
-#         result, proof = client.get_results("test_inference_cid")
-#         assert result == "test_result"
-#         assert proof == "test_proof"
-
-# def test_get_results_failed(client):
-#     with patch('src.client.requests.request') as mock_request:
-#         mock_response = Mock()
-#         mock_response.json.return_value = {"status": "failed", "error": "Test error"}
-#         mock_response.raise_for_status.return_value = None
-#         mock_request.return_value = mock_response
-
-#         with pytest.raises(InferenceError, match="Inference failed: Test error"):
-#             client.get_results("test_inference_cid")
-
-def test_infer_success(client):
-    with patch('src.client.requests.request') as mock_request:
-        mock_response = Mock()
-        mock_response.json.return_value = {"inference_cid": "test_inference_cid"}
-        mock_response.raise_for_status.return_value = None
-        mock_request.return_value = mock_response
-
-        result = client.infer("test_model_cid", {"input": [1, 2, 3]})
-        assert result == {"inference_cid": "test_inference_cid"}
-
-        mock_request.assert_called_once_with(
-            "POST",
-            "http://localhost:5002/infer",
-            json={
-                "model_cid": "test_model_cid",
-                "model_inputs": {"input": [1, 2, 3]},
-                "contract_address": "0x1234567890123456789012345678901234567890"
-            },
-            headers={"Authorization": "Bearer test_api_key"}
-        )
-
-def test_infer_invalid_input(client):
-    with pytest.raises(InvalidInputError):
-        client.infer("test_model_cid", {"invalid_input": "value"})

opengradient-0.2.8/tests/test_exceptions.py

@@ -1,25 +0,0 @@
-import pytest
-from src.exceptions import (
-    OpenGradientError, FileNotFoundError, UploadError, InferenceError,
-    ResultRetrievalError, AuthenticationError, RateLimitError, InvalidInputError,
-    ServerError, TimeoutError, NetworkError, UnsupportedModelError, InsufficientCreditsError
-)
-
-def test_open_gradient_error():
-    error = OpenGradientError("Test error", status_code=400)
-    assert str(error) == "Test error (Status code: 400)"
-
-def test_file_not_found_error():
-    error = FileNotFoundError("test_file.onnx")
-    assert str(error) == "File not found: test_file.onnx"
-
-def test_upload_error():
-    error = UploadError("Upload failed", file_path="test_file.onnx")
-    assert str(error) == "Upload failed (Status code: None)"
-    assert error.file_path == "test_file.onnx"
-
-def test_insufficient_credits_error():
-    error = InsufficientCreditsError(required_credits=100, available_credits=50)
-    assert str(error) == "Insufficient credits (Status code: None) (Required: 100, Available: 50)"
-
-# Add more tests for other exception classes

opengradient-0.2.8/tests/test_integration.py

@@ -1,20 +0,0 @@
-import pytest
-from src.client import Client
-import os
-
-@pytest.mark.integration
-def test_upload_integration():
-    client = Client(api_key="test_api_key", base_url="http://localhost:5002")
-    
-    # Create a temporary test file
-    test_file_path = "test_model.onnx"
-    with open(test_file_path, "wb") as f:
-        f.write(b"fake model content")
-    
-    try:
-        result = client.upload(test_file_path)
-        assert "model_cid" in result
-        print(f"Upload successful. Model CID: {result['model_cid']}")
-    finally:
-        # Clean up the test file
-        os.remove(test_file_path)