Data processing at scale. Built for geospatial.

from spadelib import run, RasterFile

def handler(source: RasterFile) -> RasterFile:
    # Your processing logic here
    return RasterFile(path=result)

if __name__ == "__main__":
    run(handler)

library(spadelib)

handler <- function(source) {
  # Your processing logic here
  RasterFile(path = result)
}

spade_types(handler) <- list(source = "RasterFile", .return = "RasterFile")

run(handler)

import { run, spadeBlock, RasterFile } from "spadelib";

const handler = spadeBlock({
  inputs: { source: RasterFile },
  output: RasterFile,
})(function handler({ source }: { source: RasterFile }) {
  // Your processing logic here
  return new RasterFile(resultPath);
});

await run(handler);

package main

import "github.com/krbundy/spadelib"

func handler(args *spadelib.Args) (*spadelib.RasterFile, error) {
    source, err := spadelib.Input[*spadelib.RasterFile](args, "source")
    if err != nil {
        return nil, err
    }
    // Your processing logic here
    result := spadelib.NewRasterFile(resultPath)
    return &result, nil
}

func main() {
    spadelib.Run(handler)
}

use spadelib::{run, Args, RasterFile};

fn handler(args: Args) -> Result<RasterFile, Box<dyn std::error::Error + Send + Sync>> {
    let source: RasterFile = args.input("source")?;
    // Your processing logic here
    Ok(RasterFile::new(result_path))
}

fn main() {
    run(handler);
}