Workers in your language.

from typing import Annotated
import pyarrow as pa
import pyarrow.compute as pc
from vgi import ScalarFunction, Param, Returns, Worker


class Upper(ScalarFunction):
    @classmethod
    def compute(
        cls,
        s: Annotated[pa.StringArray, Param()],
    ) -> Annotated[pa.StringArray, Returns()]:
        return pc.utf8_upper(s)


class W(Worker):
    functions = [Upper]


if __name__ == "__main__":
    W().run()

import { protocol, runStdio } from "@query-farm/vgi-rpc";

const service = protocol()
  .unary({
    name: "upper",
    params: { s: "str" },
    result: "str",
  }, ({ s }) => ({ result: s.toUpperCase() }));

await runStdio(service);

package main

import (
    "context"
    "strings"
    "github.com/Query-farm/vgi-rpc/vgirpc"
)

type UpperParams struct {
    S string `vgirpc:"s"`
}

func main() {
    server := vgirpc.NewServer()
    vgirpc.Unary(server, "upper",
      func(_ context.Context, _ *vgirpc.CallContext, p UpperParams) (string, error) {
        return strings.ToUpper(p.S), nil
      })
    server.RunStdio()
}

use std::sync::Arc;
use arrow_schema::{DataType, Field, Schema};
use vgi_rpc::{MethodInfo, RpcServer};

#[tokio::main]
async fn main() {
    let mut srv = RpcServer::builder()
        .protocol_name("MyService")
        .build();

    let params = Arc::new(Schema::new(vec![
        Field::new("s", DataType::Utf8, false),
    ]));
    let result = Arc::new(Schema::new(vec![
        Field::new("result", DataType::Utf8, false),
    ]));

    srv.register(MethodInfo::unary("upper", params, result, /* handler */));
    srv.run_stdio().await.unwrap();
}