opengradient 0.2.4__tar.gz → 0.2.5__tar.gz

{opengradient-0.2.4/src/opengradient.egg-info → opengradient-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opengradient
-Version: 0.2.4
+Version: 0.2.5
 Summary: A Python SDK for OpenGradient inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License

{opengradient-0.2.4 → opengradient-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opengradient"
-version = "0.2.4"
+version = "0.2.5"
 description = "A Python SDK for OpenGradient inference services"
 authors = [{name = "OpenGradient", email = "oliver@opengradient.ai"}]
 license = {file = "LICENSE"}

{opengradient-0.2.4 → opengradient-0.2.5}/src/opengradient/__init__.py

@@ -2,11 +2,15 @@ from .client import Client
 from .exceptions import OpenGradientError, FileNotFoundError, UploadError, InferenceError, ResultRetrievalError
 from .types import ModelInput, InferenceMode, Number, NumberTensor, StringTensor, ModelOutput
 
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 _client = None
 
-def init(private_key, rpc_url, contract_address, email="test@test.com", password="Test-123"):
+def init(private_key="cd09980ef6e280afc3900d2d6801f9e9c5d858a5deaeeab74a65643f5ff1a4c1",
+         rpc_url="http://18.218.115.248:8545",
+         contract_address="0x350E0A430b2B1563481833a99523Cfd17a530e4e",
+         email="test@test.com",
+         password="Test-123"):
     global _client
     _client = Client(private_key=private_key, rpc_url=rpc_url, contract_address=contract_address, email=email, password=password)
 
@@ -30,7 +34,7 @@ def infer(model_cid, inference_mode, model_input):
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
     return _client.infer(model_cid, inference_mode, model_input)
 
-def sign_in_with_email_and_password(email: str, password: str):
+def login(email: str, password: str):
     if _client is None:
         raise RuntimeError("OpenGradient client not initialized. Call og.init() first.")
-    return _client.sign_in_with_email_and_password(email, password)
+    return _client.login(email, password)

{opengradient-0.2.4 → opengradient-0.2.5}/src/opengradient/cli.py

@@ -40,8 +40,8 @@ Dict = DictParamType()
 # Support inference modes
 InferenceModes = {
     "VANILLA": opengradient.InferenceMode.VANILLA,
-    "ZKML": opengradient.InferenceMode.PRIVATE,
-    "TEE": opengradient.InferenceMode.VERIFIED,
+    "ZKML": opengradient.InferenceMode.ZKML,
+    "TEE": opengradient.InferenceMode.TEE,
 }
 
 # TODO (Kyle): Once we're farther into development, we should remove the defaults for these options
@@ -89,9 +89,14 @@ def cli(ctx, api_key, rpc_url, contract_address, email, password):
         click.echo(f"Failed to create OpenGradient client: {str(e)}")
 
 @cli.command()
-@click.pass_obj
-def client_settings(client):
+@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"\tAPI key ({API_KEY_ENV}): {client.private_key}")
     click.echo(f"\tRPC URL ({RPC_URL_ENV}): {client.rpc_url}")
@@ -140,14 +145,14 @@ def create_version(client, model_id, notes, is_major):
         click.echo(f"Error creating version: {str(e)}")
 
 @cli.command()
-@click.argument('model_id', type=str)
+@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_id, inference_mode, input_data, input_file):
+def infer(ctx, model_cid, inference_mode, input_data, input_file):
     """Run inference on a model"""
     client = ctx.obj
     try:
@@ -169,8 +174,8 @@ def infer(ctx, model_id, inference_mode, input_data, input_file):
                 model_input = json.load(file)
             
         # Parse input data from string to dict
-        click.echo(f"Running {inference_mode} inference for {model_id}...")
-        tx_hash, model_output = client.infer(model_cid=model_id, inference_mode=InferenceModes[inference_mode], model_input=model_input)
+        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}")

{opengradient-0.2.4 → opengradient-0.2.5}/src/opengradient/client.py

@@ -49,7 +49,7 @@ class Client:
             inference_abi = json.load(abi_file)
         self.abi = inference_abi
 
-        self.sign_in_with_email_and_password(email, password)
+        self.login(email, password)
 
     def _initialize_web3(self):
         """
@@ -104,20 +104,20 @@ class Client:
             response.raise_for_status()
 
             json_response = response.json()
-            res_model_name = json_response.get('name')
-            if not res_model_name:
-                raise Exception(f"Model creation response missing 'name'. Full response: {json_response}")
-            logging.info(f"Model creation successful. Model name: {res_model_name}")
+            model_id = json_response.get('id')
+            if not model_id:
+                raise Exception(f"Model creation response missing 'id'. Full response: {json_response}")
+            logging.info(f"Model creation successful. Model ID: {model_id}")
 
             # Create the specified version for the newly created model
             try:
-                version_response = self.create_version(res_model_name, version)
-                logging.info(f"Version creation successful. Version String: {version_response['versionString']}")
+                version_response = self.create_version(model_id, version)
+                logging.info(f"Version creation successful. Version ID: {version_response['version_id']}")
             except Exception as ve:
                 logging.error(f"Version creation failed, but model was created. Error: {str(ve)}")
-                return {"id": res_model_name, "versionString": None, "version_error": str(ve)}
+                return {"id": model_id, "version_id": None, "version_error": str(ve)}
 
-            return {"name": res_model_name, "versionString": version_response["versionString"]}
+            return {"id": model_id, "version_id": version_response["version_id"]}
 
         except requests.RequestException as e:
             logging.error(f"Model creation failed: {str(e)}")
@@ -172,14 +172,14 @@ class Client:
 
             if isinstance(json_response, list) and not json_response:
                 logging.info(f"Server returned an empty list. Assuming version was created successfully.")
-                return {"versionString": "Unknown", "note": "Created based on empty response"}
+                return {"version_id": "Unknown", "note": "Created based on empty response"}
             elif isinstance(json_response, dict):
-                version_string = json_response.get('versionString')
-                if not version_string:
-                    logging.warning(f"'versionString' not found in response. Response: {json_response}")
-                    return {"versionString": "Unknown", "note": "Version String not provided in response"}
-                logging.info(f"Version creation successful. Version String: {version_string}")
-                return {"versionString": version_string}
+                version_id = json_response.get('version_id') or json_response.get('id')
+                if not version_id:
+                    logging.warning(f"'version_id' not found in response. Response: {json_response}")
+                    return {"version_id": "Unknown", "note": "Version ID not provided in response"}
+                logging.info(f"Version creation successful. Version ID: {version_id}")
+                return {"version_id": version_id}
             else:
                 logging.error(f"Unexpected response type: {type(json_response)}. Content: {json_response}")
                 raise Exception(f"Unexpected response type: {type(json_response)}")
@@ -394,7 +394,7 @@ class Client:
             logging.error(f"Error in infer method: {str(e)}", exc_info=True)
             raise OpenGradientError(f"Inference failed: {str(e)}")
         
-    def sign_in_with_email_and_password(self, email, password):
+    def login(self, email, password):
         try:
             self.user = self.auth.sign_in_with_email_and_password(email, password)
             return self.user

{opengradient-0.2.4 → opengradient-0.2.5}/src/opengradient/types.py

@@ -23,8 +23,8 @@ class ModelInput:
 
 class InferenceMode:
     VANILLA = 0
-    PRIVATE = 1
-    VERIFIED = 2
+    ZKML = 1
+    TEE = 2
 
 @dataclass
 class ModelOutput:

{opengradient-0.2.4 → opengradient-0.2.5/src/opengradient.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: opengradient
-Version: 0.2.4
+Version: 0.2.5
 Summary: A Python SDK for OpenGradient inference services
 Author-email: OpenGradient <oliver@opengradient.ai>
 License: MIT License