SDKs

cargo add neoengine-sdk

npm install @neoengine/sdk
# or
pnpm add @neoengine/sdk
# or
yarn add @neoengine/sdk

pip install neoengine
# or
poetry add neoengine

go get github.com/neoengine-labs/neoengine-go

use neoengine_sdk::{Client, JobConfig, Resources};
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize client with API key
    let client = Client::new("your-api-key")?;
 
    // Submit a job
    let job = client
        .jobs()
        .create(JobConfig {
            image: "python:3.11-slim".into(),
            command: vec!["python", "-c", "print('Hello from NeoEngine!')"],
            resources: Resources {
                cpu: 2,
                memory: "4Gi".into(),
                gpu: None,
            },
            max_price: "1.0".into(),
            timeout: "1h".into(),
        })
        .await?;
 
    println!("Job submitted: {}", job.id);
 
    // Wait for completion
    let result = client.jobs().wait(&job.id).await?;
    println!("Output: {}", result.output);
 
    Ok(())
}

import { NeoEngine } from '@neoengine/sdk';
 
// Initialize client
const neo = new NeoEngine({ apiKey: 'your-api-key' });
 
// Submit a job
const job = await neo.jobs.create({
  image: 'python:3.11-slim',
  command: ['python', '-c', "print('Hello from NeoEngine!')"],
  resources: {
    cpu: 2,
    memory: '4Gi',
  },
  maxPrice: '1.0',
  timeout: '1h',
});
 
console.log('Job submitted:', job.id);
 
// Wait for completion
const result = await neo.jobs.wait(job.id);
console.log('Output:', result.output);

from neoengine import NeoEngine
 
# Initialize client
neo = NeoEngine(api_key="your-api-key")
 
# Submit a job
job = neo.jobs.create(
    image="python:3.11-slim",
    command=["python", "-c", "print('Hello from NeoEngine!')"],
    resources={
        "cpu": 2,
        "memory": "4Gi",
    },
    max_price="1.0",
    timeout="1h",
)
 
print(f"Job submitted: {job.id}")
 
# Wait for completion
result = neo.jobs.wait(job.id)
print(f"Output: {result.output}")

package main
 
import (
    "context"
    "fmt"
    "log"
 
    "github.com/neoengine-labs/neoengine-go"
)
 
func main() {
    // Initialize client
    client, err := neoengine.NewClient("your-api-key")
    if err != nil {
        log.Fatal(err)
    }
 
    ctx := context.Background()
 
    // Submit a job
    job, err := client.Jobs.Create(ctx, &neoengine.JobConfig{
        Image:   "python:3.11-slim",
        Command: []string{"python", "-c", "print('Hello from NeoEngine!')"},
        Resources: neoengine.Resources{
            CPU:    2,
            Memory: "4Gi",
        },
        MaxPrice: "1.0",
        Timeout:  "1h",
    })
    if err != nil {
        log.Fatal(err)
    }
 
    fmt.Printf("Job submitted: %s\n", job.ID)
 
    // Wait for completion
    result, err := client.Jobs.Wait(ctx, job.ID)
    if err != nil {
        log.Fatal(err)
    }
 
    fmt.Printf("Output: %s\n", result.Output)
}

use neoengine_sdk::{Client, Error};
 
match client.jobs().create(config).await {
    Ok(job) => println!("Success: {}", job.id),
    Err(Error::RateLimit { retry_after }) => {
        println!("Rate limited, retry after {}s", retry_after);
    }
    Err(Error::InsufficientFunds) => {
        println!("Not enough NGNX balance");
    }
    Err(e) => eprintln!("Error: {}", e),
}

import { NeoEngine, NeoEngineError } from '@neoengine/sdk';
 
try {
  const job = await neo.jobs.create(config);
} catch (error) {
  if (error instanceof NeoEngineError) {
    if (error.code === 'RATE_LIMITED') {
      console.log(`Rate limited, retry after ${error.retryAfter}s`);
    } else if (error.code === 'INSUFFICIENT_FUNDS') {
      console.log('Not enough NGNX balance');
    }
  }
}

from neoengine import NeoEngine
from neoengine.exceptions import RateLimitError, InsufficientFundsError
 
try:
    job = neo.jobs.create(config)
except RateLimitError as e:
    print(f"Rate limited, retry after {e.retry_after}s")
except InsufficientFundsError:
    print("Not enough NGNX balance")
except Exception as e:
    print(f"Error: {e}")

import "github.com/neoengine-labs/neoengine-go"
 
job, err := client.Jobs.Create(ctx, config)
if err != nil {
    switch e := err.(type) {
    case *neoengine.RateLimitError:
        fmt.Printf("Rate limited, retry after %ds\n", e.RetryAfter)
    case *neoengine.InsufficientFundsError:
        fmt.Println("Not enough NGNX balance")
    default:
        fmt.Printf("Error: %v\n", err)
    }
}