Restructure API/CLI, introduce Myxboard

remyxai/api/__init__.py

@@ -0,0 +1,24 @@
+import os
+import logging
+
+REMYXAI_API_KEY = os.getenv("REMYXAI_API_KEY")
+if not REMYXAI_API_KEY:
+    logging.error("REMYXAI_API_KEY not found in environment variables.")
+    raise ValueError("REMYXAI_API_KEY not found. Please set it with your API key.")
+else:
+    logging.info(f"Using API Key: {REMYXAI_API_KEY}")  # Log the key for debugging (only in dev)
+
+BASE_URL = "https://engine.remyx.ai/api/v1.0"
+
+HEADERS = {
+    "Authorization": f"Bearer {REMYXAI_API_KEY}",
+    "Content-Type": "application/json"
+}
+
+def log_api_response(response):
+    """Log the response from the API based on the status code."""
+    if response.status_code in [200, 201]:
+        logging.debug(f"API call successful: {response.url}, Status: {response.status_code}")
+    else:
+        logging.error(f"API call failed: {response.url}, Status: {response.status_code}, Response: {response.text}")
+

remyxai/api/deployment.py

@@ -0,0 +1,56 @@
+import os
+import shutil
+import tempfile
+import subprocess
+import requests
+from . import BASE_URL, HEADERS, log_api_response
+
+
+def download_deployment_package(model_name, output_path):
+    url = f"{BASE_URL}deployment/download/{model_name}"
+    response = requests.get(url, headers=HEADERS, stream=True)
+    if response.status_code == 200:
+        with open(output_path, "wb") as f:
+            shutil.copyfileobj(response.raw, f)
+        return response
+    else:
+        return None
+
+
+def deploy_model(model_name, action="up"):
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        model_dir = os.path.join(tmpdirname, model_name)
+        compose_file_path = os.path.join(model_dir, "docker-compose.yml")
+        zip_path = os.path.join(tmpdirname, f"{model_name}_deployment_package.zip")
+
+        if action == "up":
+            if download_deployment_package(model_name, zip_path):
+                os.makedirs(model_dir, exist_ok=True)
+                subprocess.run(["unzip", "-o", zip_path, "-d", model_dir], check=True)
+                if not os.path.exists(compose_file_path):
+                    with open(compose_file_path, "w") as f:
+                        f.write(
+                            f"""
+version: '3.8'
+services:
+  tritonserver:
+    build:
+      context: ./
+      dockerfile: Dockerfile
+    image: {model_name}:latest
+    container_name: {model_name}_triton_server
+    runtime: nvidia
+    ports:
+      - "8000:8000"
+      - "8001:8001"
+      - "8002:8002"
+    shm_size: 24G
+    restart: unless-stopped
+                        """
+                        )
+                os.chdir(model_dir)
+                subprocess.run(["docker", "compose", "up", "--build", "-d"], check=True)
+        elif action == "down":
+            if os.path.exists(compose_file_path):
+                os.chdir(model_dir)
+                subprocess.run(["docker", "compose", "down"], check=True)

remyxai/api/evaluations.py

@@ -0,0 +1,60 @@
+import logging
+import requests
+from enum import Enum
+from . import BASE_URL, HEADERS
+
+
+# Define the EvaluationTask enum
+class EvaluationTask(Enum):
+    MYXMATCH = "myxmatch"
+
+
+def list_evaluations() -> list:
+    """List all evaluations from the server."""
+    url = f"{BASE_URL}/evaluation/list"
+    logging.info(f"GET request to {url}")
+    response = requests.get(url, headers=HEADERS)
+
+    if response.status_code == 200:
+        try:
+            return response.json().get("message", [])
+        except (requests.JSONDecodeError, ValueError) as e:
+            logging.error(f"Error decoding JSON response: {e}")
+            return {"error": "Invalid JSON response"}
+    else:
+        logging.error(f"Failed to fetch evaluations: {response.status_code}")
+        return {"error": f"Failed to fetch evaluations: {response.text}"}
+
+
+def download_evaluation(eval_type: str, eval_name: str) -> dict:
+    """Download evaluation results from the server."""
+    url = f"{BASE_URL}/evaluation/download/{eval_type}/{eval_name}"
+    logging.info(f"GET request to {url}")
+    response = requests.get(url, headers=HEADERS)
+
+    if response.status_code == 200:
+        try:
+            return response.json()
+        except (requests.JSONDecodeError, ValueError) as e:
+            logging.error(f"Error decoding JSON response: {e}")
+            return {"error": "Invalid JSON response"}
+    else:
+        logging.error(f"Failed to download evaluation: {response.status_code}")
+        return {"error": f"Failed to download evaluation: {response.text}"}
+
+
+def delete_evaluation(eval_type: str, eval_name: str) -> dict:
+    """Delete an evaluation from the server."""
+    url = f"{BASE_URL}/evaluation/delete/{eval_type}/{eval_name}"
+    logging.info(f"POST request to {url}")
+    response = requests.post(url, headers=HEADERS)
+
+    if response.status_code == 200:
+        try:
+            return response.json()
+        except (requests.JSONDecodeError, ValueError) as e:
+            logging.error(f"Error decoding JSON response: {e}")
+            return {"error": "Invalid JSON response"}
+    else:
+        logging.error(f"Failed to delete evaluation: {response.status_code}")
+        return {"error": f"Failed to delete evaluation: {response.text}"}

remyxai/api/inference.py

@@ -0,0 +1,22 @@
+import time
+import numpy as np
+from tritonclient.http import InferenceServerClient, InferInput, InferRequestedOutput
+
+
+def run_inference(model_name, prompt, server_url="localhost:8000", model_version="1"):
+    triton_client = InferenceServerClient(url=server_url, verbose=False)
+    prompt_np = np.array([prompt.encode("utf-8")], dtype=object)
+    prompt_in = InferInput(name="PROMPT", shape=[1], datatype="BYTES")
+    prompt_in.set_data_from_numpy(prompt_np, binary_data=True)
+    results_out = InferRequestedOutput(name="RESULTS", binary_data=False)
+
+    start_time = time.time()
+    response = triton_client.infer(
+        model_name=model_name,
+        model_version=model_version,
+        inputs=[prompt_in],
+        outputs=[results_out],
+    )
+    elapsed_time = time.time() - start_time
+    results = response.get_response()["outputs"][0]["data"][0]
+    return results, elapsed_time