Batch Extraction Examples

Prototype

This page demonstrates the proposed mechanism for surfacing alef-generated fixture snippets (docs-site/src/snippets-generated/) in the docs. Only the batch category is wired up here; the other ~10 categories are not yet built out. See the integration design notes for the full plan before extending this to all 89 topics.

These examples are derived directly from alef’s cross-language fixture corpus and are kept in sync with the generated snippet tree automatically — no per-language import list to maintain.

Batch-extract in-memory bytes

Python

Extract multiple in-memory documents in one batch.

Python

import asyncio
from pathlib import Path
from xberg import extract_batch, ExtractInput, ExtractionConfig

async def main() -> None:
    inputs = [ExtractInput(bytes=[72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33], kind="bytes", mime_type="text/plain"), ExtractInput(bytes=Path("test_documents/html/html.html").read_bytes(), kind="bytes", mime_type="text/html")]
    _ = await extract_batch(inputs, None)

asyncio.run(main())

TypeScript / Node.js

Extract multiple in-memory documents in one batch.

TypeScript

import { extractBatch } from "@xberg-io/xberg";
async function main() {
  const result = await extractBatch([{ bytes: [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33], kind: "bytes", mimeType: "text/plain" }, { bytes: "test_documents/html/html.html", kind: "bytes", mimeType: "text/html" }], undefined);
}

void main();

WebAssembly

Extract multiple in-memory documents in one batch.

WebAssembly

import { extractBatch } from "@xberg-io/xberg-wasm";
async function main() {
  const result = await extractBatch([{ bytes: [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33], kind: "bytes", mimeType: "text/plain" }, { bytes: "test_documents/html/html.html", kind: "bytes", mimeType: "text/html" }], undefined);
}

void main();

Rust

Extract multiple in-memory documents in one batch.

Rust

use xberg::extract_batch;
use xberg::ExtractInput;

#[tokio::main]
async fn main() {
    let inputs_json: serde_json::Value = serde_json::from_str(r#"[{"bytes":[72,101,108,108,111,44,32,119,111,114,108,100,33],"kind":"bytes","mime_type":"text/plain"},{"bytes":"test_documents/html/html.html","kind":"bytes","mime_type":"text/html"}]"#).unwrap();
    let inputs_file_0 = std::fs::read(r#"test_documents/html/html.html"#).expect("file read failed");
    *inputs_json.pointer_mut(r#"/1/bytes"#).expect("docs file field missing") = serde_json::json!(inputs_file_0);
    let inputs = serde_json::from_value::<Vec<ExtractInput>>(inputs_json).unwrap();
    let config = Default::default();
    let _ = extract_batch(inputs, &config).await;
}

Go

Extract multiple in-memory documents in one batch.

Go

package main

import (
  "encoding/json"
  "fmt"
  xberg "github.com/xberg-io/xberg/packages/go"
)

func main() {
  var inputs []xberg.ExtractInput
  if err := json.Unmarshal([]byte(`[{"bytes":"SGVsbG8sIHdvcmxkIQ==","kind":"bytes","mime_type":"text/plain"},{"bytes":"test_documents/html/html.html","kind":"bytes","mime_type":"text/html"}]`), &inputs); err != nil {
    panic(fmt.Sprintf("config parse failed: %v", err))
  }
  config := xberg.ExtractionConfig{}
  result, err := xberg.ExtractBatch(inputs, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result)
}

Java

Extract multiple in-memory documents in one batch.

Java

import io.xberg.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var result = Xberg.extractBatch(java.util.Arrays.asList(JsonUtil.fromJson("{\"bytes\":[72,101,108,108,111,44,32,119,111,114,108,100,33],\"kind\":\"bytes\",\"mime_type\":\"text/plain\"}", ExtractInput.class), JsonUtil.fromJson("{\"bytes\":\"test_documents/html/html.html\",\"kind\":\"bytes\",\"mime_type\":\"text/html\"}", ExtractInput.class)), ExtractionConfig.builder().build());
        System.out.println(result);
    }
}

Kotlin (Android)

Extract multiple in-memory documents in one batch.

Kotlin (Android)

import io.xberg.*

fun main() = kotlinx.coroutines.runBlocking {
    val result = Xberg.extractBatch(listOf(MAPPER.readValue("{\"bytes\":[72,101,108,108,111,44,32,119,111,114,108,100,33],\"kind\":\"bytes\",\"mime_type\":\"text/plain\"}", ExtractInput::class.java), MAPPER.readValue("{\"bytes\":\"test_documents/html/html.html\",\"kind\":\"bytes\",\"mime_type\":\"text/html\"}", ExtractInput::class.java)), ExtractionConfig())
}

C#

Extract multiple in-memory documents in one batch.

C#

using System.Text.Json;
using Xberg;

var ConfigOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var result = await XbergConverter.ExtractBatchAsync(new List<ExtractInput>() { JsonSerializer.Deserialize<ExtractInput>("{\"bytes\":[72,101,108,108,111,44,32,119,111,114,108,100,33],\"kind\":\"bytes\",\"mime_type\":\"text/plain\"}", ConfigOptions)!, JsonSerializer.Deserialize<ExtractInput>("{\"bytes\":\"test_documents/html/html.html\",\"kind\":\"bytes\",\"mime_type\":\"text/html\"}", ConfigOptions)! }, new ExtractionConfig());

Swift

Extract multiple in-memory documents in one batch.

Swift

import Xberg

let _item_inputsArray_0 = try Xberg.extractInputFromJson("{\"bytes\":[72,101,108,108,111,44,32,119,111,114,108,100,33],\"kind\":\"bytes\",\"mime_type\":\"text/plain\"}")
let _item_inputsArray_1 = try Xberg.extractInputFromJson("{\"bytes\":\"test_documents/html/html.html\",\"kind\":\"bytes\",\"mime_type\":\"text/html\"}")
let inputsArray = [_item_inputsArray_0, _item_inputsArray_1]
let configObj = try Xberg.extractionConfigFromJson("{}")
_ = try await Xberg.extractBatch(inputs: inputsArray, config: configObj)

Ruby

Extract multiple in-memory documents in one batch.

Ruby

require "xberg"
result = Xberg.extract_batch([{ 'bytes' => [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33], 'kind' => 'bytes', 'mime_type' => 'text/plain' }, { 'bytes' => 'test_documents/html/html.html', 'kind' => 'bytes', 'mime_type' => 'text/html' }])

PHP

Extract multiple in-memory documents in one batch.

PHP

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Xberg\Xberg;
use Xberg\ExtractInput;
use Xberg\ExtractionConfig;
$result = Xberg::extractBatch([ExtractInput::from_json('{"bytes":[72,101,108,108,111,44,32,119,111,114,108,100,33],"kind":"bytes","mime_type":"text/plain"}'), ExtractInput::from_json('{"bytes":"test_documents/html/html.html","kind":"bytes","mime_type":"text/html"}')], \Xberg\ExtractionConfig::from_json('{}'));

Elixir

Extract multiple in-memory documents in one batch.

Elixir

result = Xberg.extract_batch_async([%{"bytes" => [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33], "kind" => "bytes", "mime_type" => "text/plain"}, %{"bytes" => "test_documents/html/html.html", "kind" => "bytes", "mime_type" => "text/html"}])

Dart

Extract multiple in-memory documents in one batch.

Dart

import 'dart:convert';
import 'package:xberg/xberg.dart';
import 'package:xberg/src/xberg_bridge_generated/frb_generated.dart' show RustLib;
Future<void> main() async {
  await RustLib.init();
  try {
    final inputs = await Future.wait((jsonDecode(r'[{"bytes":[72,101,108,108,111,44,32,119,111,114,108,100,33],"kind":"bytes","mime_type":"text/plain"},{"bytes":"test_documents/html/html.html","kind":"bytes","mime_type":"text/html"}]') as List<dynamic>).cast<Map<String, dynamic>>().map((m) => createExtractInputFromJson(json: jsonEncode(m))));
    final result = await XbergBridge.extractBatch(inputs);
  } finally {
    RustLib.dispose();
  }
}

Zig

Extract multiple in-memory documents in one batch.

Zig

const std = @import("std");
const xberg = @import("xberg");

pub fn main() !void {
    var gpa: std.heap.DebugAllocator(.{}) = .init;
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    const inputs_file_0 = try std.Io.Dir.cwd().readFileAlloc(std.testing.io, "test_documents/html/html.html", allocator, .unlimited);
defer allocator.free(inputs_file_0);
    const inputs_file_0_json = try std.json.Stringify.valueAlloc(allocator, inputs_file_0, .{ .emit_strings_as_arrays = true });
defer allocator.free(inputs_file_0_json);
    const inputs_json_0 = try std.mem.replaceOwned(u8, allocator, "[{\"bytes\":[72,101,108,108,111,44,32,119,111,114,108,100,33],\"kind\":\"bytes\",\"mime_type\":\"text/plain\"},{\"bytes\":\"__ALEF_DOC_FILE_0__\",\"kind\":\"bytes\",\"mime_type\":\"text/html\"}]", "\"__ALEF_DOC_FILE_0__\"", inputs_file_0_json);
defer allocator.free(inputs_json_0);
    const _result_json = try xberg.extract_batch(inputs_json_0, "{}");
    defer std.heap.c_allocator.free(_result_json);
}

C

Extract multiple in-memory documents in one batch.

C

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xberg.h"

int main(void) {
    const char *inputs_json_base = "[{\"bytes\":[72,101,108,108,111,44,32,119,111,114,108,100,33],\"kind\":\"bytes\",\"mime_type\":\"text/plain\"},{\"bytes\":\"__ALEF_DOC_FILE_0__\",\"kind\":\"bytes\",\"mime_type\":\"text/html\"}]";
    FILE *inputs_file_0 = fopen("test_documents/html/html.html", "rb");
    if (inputs_file_0 == NULL) return EXIT_FAILURE;
    fseek(inputs_file_0, 0, SEEK_END);
    long inputs_size_0 = ftell(inputs_file_0);
    if (inputs_size_0 < 0) { fclose(inputs_file_0); return EXIT_FAILURE; }
    rewind(inputs_file_0);
    uint8_t *inputs_bytes_0 = malloc(inputs_size_0 > 0 ? (size_t)inputs_size_0 : 1);
    if (inputs_bytes_0 == NULL) { fclose(inputs_file_0); return EXIT_FAILURE; }
    if (fread(inputs_bytes_0, 1, (size_t)inputs_size_0, inputs_file_0) != (size_t)inputs_size_0) { free(inputs_bytes_0); fclose(inputs_file_0); return EXIT_FAILURE; }
    fclose(inputs_file_0);
    char *inputs_bytes_json_0 = malloc((size_t)inputs_size_0 * 4 + 3);
    if (inputs_bytes_json_0 == NULL) { free(inputs_bytes_0); return EXIT_FAILURE; }
    size_t inputs_offset_0 = 0;
    inputs_bytes_json_0[inputs_offset_0++] = '[';
    for (long i = 0; i < inputs_size_0; ++i) {
        inputs_offset_0 += (size_t)snprintf(inputs_bytes_json_0 + inputs_offset_0, 5, "%s%u", i == 0 ? "" : ",", inputs_bytes_0[i]);
    }
    inputs_bytes_json_0[inputs_offset_0++] = ']';
    inputs_bytes_json_0[inputs_offset_0] = '\0';
    free(inputs_bytes_0);
    const char *inputs_marker_0 = "\"__ALEF_DOC_FILE_0__\"";
    const char *inputs_position_0 = strstr(inputs_json_base, inputs_marker_0);
    if (inputs_position_0 == NULL) { free(inputs_bytes_json_0); return EXIT_FAILURE; }
    size_t inputs_prefix_0 = (size_t)(inputs_position_0 - inputs_json_base);
    size_t inputs_json_size_0 = strlen(inputs_json_base) - strlen(inputs_marker_0) + strlen(inputs_bytes_json_0) + 1;
    char *inputs_json_0 = malloc(inputs_json_size_0);
    if (inputs_json_0 == NULL) { free(inputs_bytes_json_0); return EXIT_FAILURE; }
    snprintf(inputs_json_0, inputs_json_size_0, "%.*s%s%s", (int)inputs_prefix_0, inputs_json_base, inputs_bytes_json_0, inputs_position_0 + strlen(inputs_marker_0));
    free(inputs_bytes_json_0);
    XBERGExtractInput* inputs_handle = xberg_extract_input_from_json(inputs_json_0);
    free(inputs_json_0);
    XBERGExtractionResult* result = xberg_extract_batch(inputs_handle, NULL);
    xberg_extract_input_free(inputs_handle);
    xberg_extraction_result_free(result);
    return EXIT_SUCCESS;
}

Batch-extract with an unsupported MIME type

Python

extract_batch with unsupported bytes MIME type

Python

import asyncio
from xberg import extract_batch, ExtractInput, ExtractionConfig

async def main() -> None:
    inputs = [ExtractInput(bytes=[100, 97, 116, 97], kind="bytes", mime_type="application/x-unknown")]
    _ = await extract_batch(inputs, None)

asyncio.run(main())

TypeScript / Node.js

extract_batch with unsupported bytes MIME type

TypeScript

import { extractBatch } from "@xberg-io/xberg";
async function main() {
  const result = await extractBatch([{ bytes: [100, 97, 116, 97], kind: "bytes", mimeType: "application/x-unknown" }], undefined);
}

void main();

WebAssembly

extract_batch with unsupported bytes MIME type

WebAssembly

import { extractBatch } from "@xberg-io/xberg-wasm";
async function main() {
  const result = await extractBatch([{ bytes: [100, 97, 116, 97], kind: "bytes", mimeType: "application/x-unknown" }], undefined);
}

void main();

Rust

extract_batch with unsupported bytes MIME type

Rust

use xberg::extract_batch;
use xberg::ExtractInput;

#[tokio::main]
async fn main() {
    let inputs_json: serde_json::Value = serde_json::from_str(r#"[{"bytes":[100,97,116,97],"kind":"bytes","mime_type":"application/x-unknown"}]"#).unwrap();
    let inputs = serde_json::from_value::<Vec<ExtractInput>>(inputs_json).unwrap();
    let config = Default::default();
    let _ = extract_batch(inputs, &config).await;
}

Go

extract_batch with unsupported bytes MIME type

Go

package main

import (
  "encoding/json"
  "fmt"
  xberg "github.com/xberg-io/xberg/packages/go"
)

func main() {
  var inputs []xberg.ExtractInput
  if err := json.Unmarshal([]byte(`[{"bytes":"ZGF0YQ==","kind":"bytes","mime_type":"application/x-unknown"}]`), &inputs); err != nil {
    panic(fmt.Sprintf("config parse failed: %v", err))
  }
  config := xberg.ExtractionConfig{}
  result, err := xberg.ExtractBatch(inputs, config)
  if err != nil {
    panic(err)
  }
  fmt.Printf("%+v\n", result)
}

Java

extract_batch with unsupported bytes MIME type

Java

import io.xberg.*;

public final class Example {
    public static void main(String[] args) throws Exception {
        var result = Xberg.extractBatch(java.util.Arrays.asList(JsonUtil.fromJson("{\"bytes\":[100,97,116,97],\"kind\":\"bytes\",\"mime_type\":\"application/x-unknown\"}", ExtractInput.class)), ExtractionConfig.builder().build());
        System.out.println(result);
    }
}

Kotlin (Android)

extract_batch with unsupported bytes MIME type

Kotlin (Android)

import io.xberg.*

fun main() = kotlinx.coroutines.runBlocking {
    val result = Xberg.extractBatch(listOf(MAPPER.readValue("{\"bytes\":[100,97,116,97],\"kind\":\"bytes\",\"mime_type\":\"application/x-unknown\"}", ExtractInput::class.java)), ExtractionConfig())
}

C#

extract_batch with unsupported bytes MIME type

C#

using System.Text.Json;
using Xberg;

var ConfigOptions = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var result = await XbergConverter.ExtractBatchAsync(new List<ExtractInput>() { JsonSerializer.Deserialize<ExtractInput>("{\"bytes\":[100,97,116,97],\"kind\":\"bytes\",\"mime_type\":\"application/x-unknown\"}", ConfigOptions)! }, new ExtractionConfig());

Swift

extract_batch with unsupported bytes MIME type

Swift

import Xberg

let _item_inputsArray_0 = try Xberg.extractInputFromJson("{\"bytes\":[100,97,116,97],\"kind\":\"bytes\",\"mime_type\":\"application/x-unknown\"}")
let inputsArray = [_item_inputsArray_0]
let configObj = try Xberg.extractionConfigFromJson("{}")
_ = try await Xberg.extractBatch(inputs: inputsArray, config: configObj)

Ruby

extract_batch with unsupported bytes MIME type

Ruby

require "xberg"
result = Xberg.extract_batch([{ 'bytes' => [100, 97, 116, 97], 'kind' => 'bytes', 'mime_type' => 'application/x-unknown' }])

PHP

extract_batch with unsupported bytes MIME type

PHP

<?php

declare(strict_types=1);

require_once __DIR__ . '/vendor/autoload.php';

use Xberg\Xberg;
use Xberg\ExtractInput;
use Xberg\ExtractionConfig;
$result = Xberg::extractBatch([ExtractInput::from_json('{"bytes":[100,97,116,97],"kind":"bytes","mime_type":"application/x-unknown"}')], \Xberg\ExtractionConfig::from_json('{}'));

Elixir

extract_batch with unsupported bytes MIME type

Elixir

result = Xberg.extract_batch_async([%{"bytes" => [100, 97, 116, 97], "kind" => "bytes", "mime_type" => "application/x-unknown"}])

Dart

extract_batch with unsupported bytes MIME type

Dart

import 'dart:convert';
import 'package:xberg/xberg.dart';
import 'package:xberg/src/xberg_bridge_generated/frb_generated.dart' show RustLib;
Future<void> main() async {
  await RustLib.init();
  try {
    final inputs = await Future.wait((jsonDecode(r'[{"bytes":[100,97,116,97],"kind":"bytes","mime_type":"application/x-unknown"}]') as List<dynamic>).cast<Map<String, dynamic>>().map((m) => createExtractInputFromJson(json: jsonEncode(m))));
    final result = await XbergBridge.extractBatch(inputs);
  } finally {
    RustLib.dispose();
  }
}

Zig

extract_batch with unsupported bytes MIME type

Zig

const std = @import("std");
const xberg = @import("xberg");

pub fn main() !void {
    const _result_json = try xberg.extract_batch("[{\"bytes\":[100,97,116,97],\"kind\":\"bytes\",\"mime_type\":\"application/x-unknown\"}]", "{}");
    defer std.heap.c_allocator.free(_result_json);
}

C

extract_batch with unsupported bytes MIME type

C

#include <assert.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "xberg.h"

int main(void) {
    XBERGExtractInput* inputs_handle = xberg_extract_input_from_json("[{\"bytes\":[100,97,116,97],\"kind\":\"bytes\",\"mime_type\":\"application/x-unknown\"}]");
    XBERGExtractionResult* result = xberg_extract_batch(inputs_handle, NULL);
    xberg_extract_input_free(inputs_handle);
    xberg_extraction_result_free(result);
    return EXIT_SUCCESS;
}