nexuscompute-sdk 2.0.0__py3-none-any.whl

nexus_sdk/__init__.py

@@ -0,0 +1,8 @@
+from .client import Renter
+from .provider import Provider, detect_hardware
+
+__all__ = [
+    "Renter",
+    "Provider",
+    "detect_hardware",
+]

nexus_sdk/cli.py

@@ -0,0 +1,165 @@
+import sys
+import argparse
+import json
+from .client import Renter
+from .provider import Provider, detect_hardware
+
+def renter_cli():
+    parser = argparse.ArgumentParser(description="NexusCompute Renter CLI Client")
+    parser.add_argument("--api-key", help="API key for authentication")
+    parser.add_argument("--token", help="Bearer token for authentication")
+    parser.add_argument("--api-url", default="http://localhost:3002/api/v1", help="Nexus API Endpoint URL")
+    
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    
+    # signup
+    signup_parser = subparsers.add_parser("signup", help="Create a marketplace account")
+    signup_parser.add_argument("-e", "--email", required=True, help="Account email")
+    signup_parser.add_argument("-p", "--password", required=True, help="Account password")
+    
+    # login
+    login_parser = subparsers.add_parser("login", help="Authenticate and get token")
+    login_parser.add_argument("-e", "--email", required=True, help="Account email")
+    login_parser.add_argument("-p", "--password", required=True, help="Account password")
+    
+    # pay
+    pay_parser = subparsers.add_parser("pay", help="Add USD balance via Square")
+    pay_parser.add_argument("-a", "--amount", default="5.00", help="Amount in USD")
+    pay_parser.add_argument("-n", "--nonce", default="cnon:card-nonce-ok", help="Square nonce")
+    
+    # train
+    train_parser = subparsers.add_parser("train", help="Submit a training job")
+    train_parser.add_argument("-m", "--model", default="gemma-4-e2b-it", help="Model name")
+    train_parser.add_argument("-d", "--dataset", default="synthetic", help="Dataset name")
+    train_parser.add_argument("-e", "--epochs", default="3", help="Training epochs")
+    train_parser.add_argument("-c", "--compute", default="local", help="local or colab compute")
+    train_parser.add_argument("-p", "--prompt", help="Natural language training prompt")
+    
+    # status
+    status_parser = subparsers.add_parser("status", help="Check wallet, jobs, or job status")
+    status_parser.add_argument("-j", "--job", help="Specific job ID")
+    
+    # contribute
+    contribute_parser = subparsers.add_parser("contribute", help="Open an agent contribution task")
+    contribute_parser.add_argument("-a", "--agent", required=True, help="Partner agent name/id")
+    contribute_parser.add_argument("-t", "--task", required=True, help="Contribution task description")
+    contribute_parser.add_argument("-j", "--job", help="Linked training job ID")
+    
+    # list-hardware
+    subparsers.add_parser("list-hardware", help="List all active providers / compute hardware")
+    
+    # get-wallet
+    subparsers.add_parser("get-wallet", help="Check renter wallet token balance")
+
+    # benchmark
+    benchmark_parser = subparsers.add_parser("benchmark", help="Run benchmark on target hardware")
+    benchmark_parser.add_argument("-H", "--hardware", required=True, help="Target hardware node ID")
+    benchmark_parser.add_argument("-s", "--size", default="512", help="Matrix size")
+    benchmark_parser.add_argument("-i", "--iterations", default="3", help="Number of iterations")
+    benchmark_parser.add_argument("-b", "--backend", default="cpu", help="Execution backend")
+
+    # gemm
+    gemm_parser = subparsers.add_parser("gemm", help="Submit General Matrix Multiply operation")
+    gemm_parser.add_argument("-H", "--hardware", required=True, help="Target hardware node ID")
+    gemm_parser.add_argument("-a", "--matrix-a", required=True, help="Matrix A (JSON nested array, e.g. [[1,2]])")
+    gemm_parser.add_argument("-b", "--matrix-b", required=True, help="Matrix B (JSON nested array, e.g. [[3,4]])")
+    gemm_parser.add_argument("-t", "--transpose-a", action="store_true", help="Transpose matrix A")
+    gemm_parser.add_argument("-u", "--transpose-b", action="store_true", help="Transpose matrix B")
+    gemm_parser.add_argument("-k", "--backend", default="cpu", help="Execution backend")
+    
+    args = parser.parse_args()
+    
+    client = Renter(api_key=args.api_key, token=args.token, base_url=args.api_url)
+    
+    try:
+        if args.command == "signup":
+            res = client.register(args.email, args.password)
+            print(f"Signed up successfully as {res.get('user', {}).get('email')}")
+            print(json.dumps(res, indent=2))
+        elif args.command == "login":
+            res = client.login(args.email, args.password)
+            print(f"Logged in successfully. Session token saved.")
+            print(json.dumps(res, indent=2))
+        elif args.command == "pay":
+            res = client.pay(args.amount, args.nonce)
+            print(json.dumps(res, indent=2))
+        elif args.command == "train":
+            payload = {
+                "model": args.model,
+                "dataset": args.dataset,
+                "epochs": int(args.epochs),
+                "computeTarget": args.compute,
+                "prompt": args.prompt
+            }
+            res = client.train(payload)
+            print(json.dumps(res, indent=2))
+        elif args.command == "status":
+            if args.job:
+                res = client.get_job(args.job)
+            else:
+                res = client.list_jobs()
+            print(json.dumps(res, indent=2))
+        elif args.command == "contribute":
+            payload = {
+                "agentId": args.agent,
+                "taskDescription": args.task
+            }
+            if args.job:
+                payload["linkedJobId"] = args.job
+            res = client.contribute(payload)
+            print(json.dumps(res, indent=2))
+        elif args.command == "list-hardware":
+            res = client.list_hardware()
+            print(json.dumps(res, indent=2))
+        elif args.command == "get-wallet":
+            res = client.get_wallet()
+            print(json.dumps(res, indent=2))
+        elif args.command == "benchmark":
+            payload = {
+                "hardwareId": args.hardware,
+                "size": int(args.size),
+                "iterations": int(args.iterations),
+                "backend": args.backend
+            }
+            res = client.quote_train(payload) if False else client._request("POST", "/ops/benchmark", json=payload)
+            print(json.dumps(res, indent=2))
+        elif args.command == "gemm":
+            payload = {
+                "hardwareId": args.hardware,
+                "a": json.loads(args.matrix_a),
+                "b": json.loads(args.matrix_b),
+                "transposeA": args.transpose_a,
+                "transposeB": args.transpose_b,
+                "backend": args.backend
+            }
+            res = client._request("POST", "/ops/gemm", json=payload)
+            print(json.dumps(res, indent=2))
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def provider_cli():
+    parser = argparse.ArgumentParser(description="NexusCompute Provider Agent Daemon")
+    parser.add_argument("--token", help="Hardware node connection token")
+    parser.add_argument("--api-url", default="http://localhost:3002/api/v1", help="Nexus API Endpoint URL")
+    parser.add_argument("--detect", action="store_true", help="Detect system specifications and print them as JSON")
+    
+    args = parser.parse_args()
+    
+    if args.detect:
+        hw = detect_hardware()
+        print(json.dumps(hw, indent=2))
+        sys.exit(0)
+        
+    if not args.token:
+        parser.print_help()
+        print("\nError: --token is required to run the provider agent.", file=sys.stderr)
+        sys.exit(1)
+        
+    try:
+        agent = Provider(token=args.token, api_url=args.api_url)
+        agent.start()
+    except Exception as e:
+        print(f"Fatal: {e}", file=sys.stderr)
+        sys.exit(1)

nexus_sdk/client.py

@@ -0,0 +1,137 @@
+import requests
+import time
+
+class Renter:
+    def __init__(self, api_key=None, token=None, base_url="http://localhost:3002/api/v1"):
+        self.api_key = api_key
+        self.token = token
+        self.base_url = base_url.rstrip("/")
+
+    def _headers(self):
+        headers = {"Content-Type": "application/json"}
+        if self.api_key:
+            headers["X-API-Key"] = self.api_key
+        elif self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+        return headers
+
+    def _request(self, method, path, json=None, params=None):
+        url = f"{self.base_url}{path}"
+        res = requests.request(method, url, json=json, params=params, headers=self._headers())
+        if not res.ok:
+            try:
+                err_msg = res.json().get("error", f"HTTP {res.status_code}")
+            except Exception:
+                err_msg = f"HTTP {res.status_code}"
+            raise RuntimeError(err_msg)
+        try:
+            return res.json()
+        except Exception:
+            return {}
+
+    def login(self, email, password):
+        data = self._request("POST", "/auth/login", json={"email": email, "password": password})
+        self.token = data.get("token")
+        return data
+
+    def register(self, email, password):
+        data = self._request("POST", "/auth/register", json={"email": email, "password": password})
+        self.token = data.get("token")
+        return data
+
+    def create_api_key(self, name):
+        return self._request("POST", "/auth/api-keys", json={"name": name})
+
+    def list_hardware(self, **params):
+        return self._request("GET", "/hardware", params=params)
+
+    def get_hardware(self, hardware_id):
+        return self._request("GET", f"/hardware/{hardware_id}")
+
+    def get_priority_tiers(self):
+        return self._request("GET", "/network/priority-tiers")
+
+    def get_exchange_rate(self):
+        return self._request("GET", "/exchange/rate")
+
+    def get_wallet(self):
+        return self._request("GET", "/exchange/wallet")
+
+    def exchange_usd_to_nexus(self, usd_amount):
+        return self._request("POST", "/exchange/usd-to-nexus", json={"usdAmount": usd_amount})
+
+    def get_exchange_history(self, limit=20):
+        return self._request("GET", "/exchange/history", params={"limit": limit})
+
+    def submit_job(self, target, operation, params=None, backend=None, priority=None, priority_tier=None, scheduled_at=None):
+        if params is None:
+            params = {}
+        if isinstance(target, dict):
+            hardware_id = target.get("hardwareId")
+            priority_tier = target.get("priorityTier", priority_tier) or "standard"
+        else:
+            hardware_id = target
+            priority_tier = priority_tier or "standard"
+
+        if not hardware_id:
+            raise ValueError("hardwareId is required")
+
+        body = {
+            "hardwareId": hardware_id,
+            "priorityTier": priority_tier,
+            "operation": operation,
+            "params": params
+        }
+        if backend:
+            body["backend"] = backend
+        if priority:
+            body["priority"] = priority
+        if scheduled_at:
+            body["scheduledAt"] = scheduled_at
+
+        return self._request("POST", "/jobs", json=body)
+
+    def get_job(self, job_id):
+        return self._request("GET", f"/jobs/{job_id}")
+
+    def wait_for_job(self, job_id, max_ms=60000, poll_ms=250):
+        start = time.time()
+        while (time.time() - start) * 1000 < max_ms:
+            job = self.get_job(job_id)
+            if job.get("status") == "completed":
+                return job
+            if job.get("status") == "failed":
+                raise RuntimeError(job.get("error", "Job failed"))
+            time.sleep(poll_ms / 1000.0)
+        raise TimeoutError("Timed out waiting for job completion")
+
+    def get_network_stats(self):
+        return self._request("GET", "/network/stats")
+
+    def get_pricing(self):
+        return self._request("GET", "/network/pricing")
+
+    def get_backends(self):
+        return self._request("GET", "/ops/backends")
+
+    def pay(self, amount_usd, source_id):
+        return self._request("POST", "/payments/charge", json={
+            "amountUsd": float(amount_usd),
+            "sourceId": source_id
+        })
+
+    def train(self, payload):
+        return self._request("POST", "/marketplace/train", json=payload)
+
+    def quote_train(self, payload):
+        return self._request("POST", "/marketplace/train/quote", json=payload)
+
+    def list_jobs(self):
+        return self._request("GET", "/marketplace/train")
+
+    def contribute(self, payload):
+        return self._request("POST", "/marketplace/contribute", json=payload)
+
+    def list_contributions(self):
+        return self._request("GET", "/marketplace/contribute")
+

nexus_sdk/provider.py

@@ -0,0 +1,214 @@
+import os
+import sys
+import time
+import shutil
+import socket
+import platform
+import subprocess
+import requests
+import psutil
+
+def detect_hardware():
+    # 1. Total CPU cores and system memory
+    total_mem_gb = round(psutil.virtual_memory().total / (1024 ** 3), 1)
+    free_mem_gb = round(psutil.virtual_memory().available / (1024 ** 3), 1)
+    cpu_count = psutil.cpu_count(logical=False) or 1
+    
+    hardware = {
+        "type": "cpu",
+        "model": platform.processor() or "Generic CPU",
+        "cores": cpu_count,
+        "memory": {
+            "totalGb": total_mem_gb,
+            "freeGb": free_mem_gb
+        },
+        "gpus": []
+    }
+
+    # 2. Try to detect NVIDIA GPUs via nvidia-smi
+    nvidia_smi = shutil.which("nvidia-smi")
+    if nvidia_smi:
+        try:
+            output = subprocess.check_output([
+                nvidia_smi,
+                "--query-gpu=name,memory.total,memory.free,utilization.gpu,utilization.memory,temperature.gpu,power.draw",
+                "--format=csv,noheader,nounits"
+            ], encoding="utf-8")
+            
+            gpus = []
+            for line in output.strip().splitlines():
+                parts = [p.strip() for p in line.split(",")]
+                if len(parts) >= 7:
+                    gpu_name = parts[0]
+                    total_vram = float(parts[1])
+                    free_vram = float(parts[2])
+                    gpu_util = float(parts[3])
+                    mem_util = float(parts[4])
+                    temp = float(parts[5])
+                    power = float(parts[6])
+
+                    gpus.append({
+                        "name": gpu_name,
+                        "vramTotalMb": total_vram,
+                        "vramFreeMb": free_vram,
+                        "utilization": gpu_util,
+                        "memoryUsedPercent": mem_util,
+                        "temperature": temp,
+                        "powerDraw": power
+                    })
+            if gpus:
+                hardware["type"] = "gpu"
+                hardware["model"] = gpus[0]["name"]
+                hardware["vramGb"] = round(sum(g["vramTotalMb"] for g in gpus) / 1024.0, 1)
+                hardware["gpus"] = gpus
+        except Exception:
+            pass
+            
+    return hardware
+
+
+class Provider:
+    def __init__(self, token, api_url="http://localhost:3002/api/v1", detect_interval_secs=60, heartbeat_secs=15, poll_secs=5):
+        self.token = token
+        self.api_url = api_url.rstrip("/")
+        self.detect_interval_secs = detect_interval_secs
+        self.heartbeat_secs = heartbeat_secs
+        self.poll_secs = poll_secs
+        self.node_id = None
+        self.cached_hardware = None
+        self.cached_hardware_at = 0
+
+    def _headers(self):
+        return {
+            "Content-Type": "application/json",
+            "X-Node-Token": self.token
+        }
+
+    def _request(self, method, path, json=None):
+        url = f"{self.api_url}{path}"
+        res = requests.request(method, url, json=json, headers=self._headers())
+        if not res.ok:
+            try:
+                err_msg = res.json().get("error", f"HTTP {res.status_code}")
+            except Exception:
+                err_msg = f"HTTP {res.status_code}"
+            raise RuntimeError(err_msg)
+        try:
+            return res.json()
+        except Exception:
+            return {}
+
+    def get_hardware_detection(self):
+        now = time.time()
+        if not self.cached_hardware or now - self.cached_hardware_at > self.detect_interval_secs:
+            self.cached_hardware = detect_hardware()
+            self.cached_hardware_at = now
+            hw = self.cached_hardware
+            gpus_text = f", {len(hw['gpus'])} GPU(s)" if hw["gpus"] else ""
+            print(f"[detect] {hw['type']} {hw['model']} — {hw['memory']['totalGb']} GB RAM, {hw['cores']} cores{gpus_text}")
+        return self.cached_hardware
+
+    def build_telemetry(self, hardware):
+        gpus = hardware.get("gpus", [])
+        if gpus:
+            gpu_util = sum(g["utilization"] for g in gpus) / len(gpus)
+            gpu_mem = sum(g["memoryUsedPercent"] for g in gpus) / len(gpus)
+            temp = sum(g["temperature"] for g in gpus) / len(gpus)
+            power = sum(g["powerDraw"] for g in gpus)
+            return {
+                "gpuUtilization": round(gpu_util, 1),
+                "gpuMemory": round(gpu_mem, 1),
+                "temperature": round(temp, 1),
+                "powerDraw": round(power, 1),
+                "cpuCompute": 0,
+                "cpuMemory": round(((hardware["memory"]["totalGb"] - hardware["memory"]["freeGb"]) / hardware["memory"]["totalGb"]) * 100, 1)
+            }
+        else:
+            return {
+                "gpuUtilization": 0,
+                "gpuMemory": 0,
+                "temperature": 0,
+                "powerDraw": 0,
+                "cpuCompute": round(psutil.cpu_percent(), 1),
+                "cpuMemory": round(((hardware["memory"]["totalGb"] - hardware["memory"]["freeGb"]) / hardware["memory"]["totalGb"]) * 100, 1)
+            }
+
+    def collect_metrics(self):
+        hardware = self.get_hardware_detection()
+        return {
+            "hostname": socket.gethostname(),
+            "platform": sys.platform,
+            "cpus": psutil.cpu_count(logical=True),
+            "memoryUsedMb": round(psutil.Process(os.getpid()).memory_info().rss / (1024 ** 2), 1),
+            "uptime": round(time.time() - psutil.boot_time()),
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "hardware": hardware,
+            "telemetry": self.build_telemetry(hardware),
+            "relay": {
+                "host": "localhost",
+                "port": 0,
+                "url": None
+            }
+        }
+
+    def heartbeat(self):
+        metrics = self.collect_metrics()
+        data = self._request("POST", "/nodes/heartbeat", json={"metrics": metrics})
+        if data.get("nodeId"):
+            self.node_id = data["nodeId"]
+        return data
+
+    def poll_jobs(self):
+        try:
+            data = self._request("GET", "/nodes/jobs/next")
+            if data.get("nodeId"):
+                self.node_id = data["nodeId"]
+            job = data.get("job")
+            if not job or job.get("status") != "running":
+                return
+
+            print(f"[job] received job {job.get('operation')} ({job.get('id')})")
+            
+            # Simple mock execution for Python SDK provider
+            try:
+                print(f"[job] executing {job.get('operation')}...")
+                time.sleep(1) # Simulation
+                result = {"status": "success", "message": "Python SDK mock execution successful"}
+                
+                self._request("POST", f"/nodes/jobs/{job.get('id')}/complete", json={
+                    "result": result,
+                    "ttftMs": 100
+                })
+                print(f"[job] completed {job.get('id')}")
+            except Exception as ex:
+                self._request("POST", f"/nodes/jobs/{job.get('id')}/complete", json={
+                    "error": str(ex)
+                })
+                print(f"[job] failed {job.get('id')}: {ex}")
+        except Exception as e:
+            print(f"[job] poll error: {e}")
+
+    def start(self):
+        print("NexusCompute Python Provider SDK starting")
+        print(f"  Platform: {platform.platform()}")
+        print(f"  API:      {self.api_url}")
+        
+        first = self.heartbeat()
+        print(f"  Node ID:  {self.node_id or first.get('nodeId')} (assigned by server)")
+
+        last_heartbeat = time.time()
+        last_poll = time.time()
+
+        print("Provider agent running. Press Ctrl+C to stop.")
+        try:
+            while True:
+                now = time.time()
+                if now - last_heartbeat >= self.heartbeat_secs:
+                    self.heartbeat()
+                    last_heartbeat = now
+                if now - last_poll >= self.poll_secs:
+                    self.poll_jobs()
+                    last_poll = now
+                time.sleep(1)
+        except KeyboardInterrupt:
+            print("\nStopping provider agent...")

nexuscompute_sdk-2.0.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: nexuscompute-sdk
+Version: 2.0.0
+Summary: NexusCompute Unified SDK — python client for renting compute and hosting provider nodes
+Author: NexusCompute
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Requires-Dist: requests>=2.25.0
+Requires-Dist: psutil>=5.8.0
+Dynamic: author
+Dynamic: classifier
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

nexuscompute_sdk-2.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+nexus_sdk/__init__.py,sha256=XcRGnlv_kLkdUG0UUovqpStSIdid3A69eQ7Kz27lFws,143
+nexus_sdk/cli.py,sha256=e3Zrp_ZIQ3-2kSXMEJMGWg8Cne1NrOcesBUR5FVVjWw,7744
+nexus_sdk/client.py,sha256=xDdAllqVnhplW8f_9H-dPXuSeaNi0_FUVqWJ8hKvr0Y,4785
+nexus_sdk/provider.py,sha256=W9QvTCIAiCmsji8v5GlST4aL_82SpdwLk4p0wq-bBmE,8145
+nexuscompute_sdk-2.0.0.dist-info/METADATA,sha256=JTqW50MY4shCYZwSaVp9z6wwO5JuMXjdsnN8bam-UGc,527
+nexuscompute_sdk-2.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+nexuscompute_sdk-2.0.0.dist-info/entry_points.txt,sha256=AwBChgPvlLcgujrgDUBy6KQ-ktrdubqO2mF5-CdGQeI,102
+nexuscompute_sdk-2.0.0.dist-info/top_level.txt,sha256=pnVwzorEN7yUu42HPO_hoXtI3QxHS956R0LyyG7yueI,10
+nexuscompute_sdk-2.0.0.dist-info/RECORD,,

nexuscompute_sdk-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nexuscompute_sdk-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+nexus-provider = nexus_sdk.cli:provider_cli
+nexus-renter = nexus_sdk.cli:renter_cli

nexuscompute_sdk-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nexus_sdk