Skip to main content

dataio

CI PyPI Python

A Rust-backed data-loading library for files, object stores, tensors, and columnar data. The native runtime fetches, decodes, transforms, and batches across a shared worker pool, with NumPy, PyTorch, DLPack, and Arrow outputs. One URI surface covers local files, S3 / R2, GCS, Azure, and Hugging Face; direct reads and reusable pipelines share the same IO layer.

import dataio

pipe = dataio.pipeline(
    dataio.slot("image")
        .decode_image(mode="rgb")
        .resize_short(256)
        .center_crop(h=224, w=224)
        .normalize("imagenet"),
    dataio.batch(64, prefetch=4),
)

with pipe.bind(records).run("torch", concurrency=64) as loader:
    for batch in loader:
        train_step(batch["image"])

Why dataio

  • Native fast path. Decode, resize, normalize, and collate are Rust kernels on a shared pool. Native IO and kernels release the GIL; optional Python source and map callbacks retain their Python execution costs.
  • Shared-buffer outputs. Native tensors can reach PyTorch through DLPack, and compatible reads can view memory-mapped storage. Copies depend on mutability, alignment, layout and device transfer; retained views own their backing storage.
  • One surface, every backend. s3://, gs://, az://, hf://, and local paths share the same pipeline ops and the same flat IO verbs.
  • Reproducible streams. Deterministic sharding, seeded shuffle, and checkpoint resume that replays a partial batch so transform RNG stays aligned across a restart.

Install

pip install dataio-rs

Python 3.11 or newer. Wheels are CPU-safe by default; CUDA, nvJPEG, and cuFile / GDS are discovered lazily when used, so the same wheel runs on a laptop or an 8-GPU node. Print the capability report for the current host:

python -m dataio

Pipeline

A pipeline is a static plan: optional record maps, one or more slot chains, exactly one shape stage (batch / collate / group_by), and optional post-batch maps or native batch transforms. Building it does no work — binding a record source and calling .run() starts the runtime.

pipe = dataio.pipeline(
    dataio.map(lambda r: {"image": r["path"], "label": r["class_id"]}),

    dataio.slot("image")
        .decode_image(mode="rgb")
        .resize_short(256)
        .center_crop(h=224, w=224)
        .normalize("imagenet"),

    dataio.slot("label").passthrough(),
    dataio.batch(64, drop_last=True, prefetch=4),
)

Op factories are grouped into namespaces; the slot methods (.decode_image(), .resize(), .normalize(), …) are shorthand for the same native ops.

Namespace Purpose
dataio.decoders image, audio, json, npy, safetensors, text, bytes, pt
dataio.transforms resize, crop, normalize, augment, conditional ops
dataio.batch_transforms mixup, cutmix, padding, shuffle, normalization
dataio.cond predicates for slot-local conditional transforms and skips

Audio decoding can opt into anti-aliased sample-rate conversion with slot("audio").decode_audio(sample_rate=16000, resampling="sinc") or dataio.decoders.audio(sample_rate=16000, resampling="sinc"). The default resampling="linear" preserves existing behavior and costs less computation.

Record sources and shuffle

Record sources compose before native decoding. map_records(fn) maps one record to one record; flat_map_records(fn) emits zero or more child records in order. concat(...) appends sources without opening later ones early:

def expand(record):
    for index, payload in enumerate(record["parts"]):
        yield {"key": f"{record['key']}:{index}", "payload": payload}

records = dataio.records(group_a).concat(group_b).flat_map_records(expand)

Return an iterable of complete child records; wrap a single mapping or byte record in a list. Expansion has unknown length and requires bounded shuffle. Concatenation has a known length only when all children do; an infinite child prevents later sources from being reached. See the runnable source composition example.

Bind a reusable iterable or a zero-argument record factory for repeated passes. from_iterable(...) is explicitly single-pass, even when given a factory; construct another adapter for another pass. bind uses indexed access for lists, tuples and other collections.abc.Sequence instances. Other objects use an explicit __iter__, or Python's legacy __getitem__ iteration when absent; __iter__ = None disables iteration for non-Sequence objects. A zero-argument callable can still be a bind factory. from_iterable follows Python's iter() protocol when an iteration method is present, including rejection of __iter__ = None; it does not switch such an object to factory mode.

For a finite third-party dataset, explicitly choose integer row access with dataio.records(dataset, indexed=True). This declares that integer __getitem__ returns one record and requires a finite __len__; it bypasses the dataset's iterator without reading any rows at construction. It accepts reusable datasets, not one-shot streams, mappings or individual paths/buffers. An object with integer column lookup needs a row adapter first.

With batch(N), indexed sources may implement __getitems__(indices) to read the requested rows together. Return a list or tuple of exactly that many records, in the requested order, including duplicates. The loader snapshots the outer container's references before running row maps; it does not deep-copy the records. The whole fetch completes before per-record maps run, so side-effect ordering differs from alternating scalar reads and maps. Exceptions and invalid results propagate without retrying scalar reads. An absent method or None uses scalar access; other non-callable values are errors. This protocol does not interpret dataset[indices] column dictionaries as rows.

Unbuffered indexed shuffle forwards remapped indices to the bulk method. Filtering, expansion and concatenation do not forward the original bulk method. collate() and group_by() continue to read items individually. See the indexed/callable example for bulk reads followed by a custom Python collator.

Record sources also support bounded shuffle:

records = dataio.webdataset("/data/shard-{0000..0099}.tar").shuffle(
    seed=42, buffer_size=4096,
)

buffer_size bounds pending records in the shuffle buffer; it is not a byte or total-memory limit. Buffered shuffle mixes nearby records rather than producing a uniform permutation of the whole dataset. It also works with single-pass from_iterable sources. A fixed seed repeats the order only when the source is re-iterable and unchanged; use a different seed for each epoch to reshuffle. Omitting buffer_size retains the full permutation behavior, including materialization of non-indexed sources and rejection of single-pass sequential sources. Mapping and filtering after a buffered shuffle stay lazy.

Python transforms and structured batches

Source transforms and dataio.map(...) before the batch boundary see input records, before native decoding. Native slot chains perform decoding and tensor transforms. Python maps after batch, collate or group_by receive the decoded Batch and may return any nested mapping, tuple or application object. They run on the consumer thread; they are not callbacks between native ops.

For an existing Python collate_fn, pass raw samples through an object slot:

pipe = dataio.pipeline(
    dataio.slot("sample").passthrough(),
    dataio.batch(32),
    dataio.map(lambda batch: collate_fn(batch["sample"])),
)

Here each input record contains a sample value. For native tensor slots, use a batch map to assemble the desired nested result from batch["slot_name"]. collate() itself preserves upstream batch boundaries; it does not take a Python collate function. Native batch transforms must precede Python batch maps.

Padding and batch normalization retain row keys, indices, original image sizes and passthrough values. MixUp and CutMix combine rows, so those metadata accesses remain unavailable afterward; len(batch) and repr(batch) still work.

Slot-local conditionals

dataio.cond builds native predicates that compile into the plan signature. Field predicates run before decode, so they can gate optional slots; shape predicates run after decode and live inside transform branches.

from dataio import cond as c

pipe = dataio.pipeline(
    dataio.slot("image").decode_image(mode="rgb"),
    dataio.slot("mask", optional=True)
        .active_when(c.col("mask_id").is_not_null())
        .decode_image(mode="gray"),
    dataio.batch(32),
)

# Shape-driven branching after decode
dataio.slot("image") \
    .decode_image(mode="rgb") \
    .when(c.shape(axis=0).gt(512)) \
    .then(dataio.transforms.center_crop(h=512, w=512)) \
    .otherwise(dataio.transforms.resize(h=512, w=512))

Grouped batches

When an upstream sampler owns batch boundaries, group_by emits one batch per contiguous run of a key. Pair it with from_sampler to adapt a PyTorch-style BatchSampler (or any iterable yielding lists of rows). A passthrough slot carries per-record metadata alongside decoded data:

pipe = dataio.pipeline(
    dataio.slot("payload").decode_numpy(),
    dataio.slot("meta").passthrough(),
    dataio.group_by("batch_id", prefetch=4),
)

records = dataio.from_sampler(
    batch_sampler,
    lambda row: {
        "key": row["id"],
        "payload": row["path"],
        "meta": row,
    },
)

with pipe.bind(records).run("numpy", concurrency=32) as loader:
    for batch in loader:
        arrays = batch["payload"]
        rows = batch["meta"]  # aligned with surviving batch.keys

from_sampler injects the batch_id field for you. The record_fn argument is optional — omit it when the sampler already yields valid record mappings. The adapter shallow-copies each mapping before adding the batch ID; nested values remain shared.

Runtime

pipe.bind(records).run(...) returns a context-managed loader. Worker pools are process-wide and set once via environment variables; per-loader knobs control admission and prefetch:

Knob Meaning
run(..., concurrency=N) per-shard stage admission window; total activity also depends on prefetch depth
dataio.batch(..., prefetch=K) number of batches in flight
run(..., max_prefetch_bytes=B) optional bound on logical bytes of native preallocated outputs waiting for delivery
DATAIO_CPU_WORKERS size of the shared CPU decode/transform pool
DATAIO_IO_WORKERS size of the shared async IO runtime
DATAIO_OBJECT_SHARDS HTTP / object-store shard fanout
DATAIO_S3_HTTP_VERSION h1 or h2 transport selection
DATAIO_TCP_QUICKACK Linux small-response ACK tuning; defaults to 1, set 0 before creating connections to disable

concurrency="auto" (the default) is enough for local data and moderate batches; raise it for remote object reads or high-latency sources. Output preserves submit order by default — pass order="completion" to yield each batch as soon as it finishes.

The byte limit requires a fixed native output layout and a direct output writer, such as image decode → resize → CHW normalization. Unsupported variable or object outputs and oversized batches fail before allocation. The limit covers pending native outputs, including reordered results; it is not an RSS limit and excludes decode temporaries, pool retention, collation and outputs held by callers.

With .run("torch", device="cuda:0"), pinned CPU outputs wait for the target CUDA stream's copy to finish before their host storage can be reused. This preserves values at the cost of asynchronous copy overlap and small-transfer latency. Native CUDA outputs keep their stream-ordered DLPack handoff.

Error handling

loader = pipe.bind(records).run("torch", on_failure="skip")
on_failure Behavior
"strict" raise on the first row error
"skip" drop failed rows, raise only if a batch has no survivors
0, 1, … require at least that many survivors per batch

Per-row errors land on batch.errors. For automatic logging, pass log_errors=True (routes through the dataio.rows logger) or a callable for custom handling:

loader = pipe.bind(records).run("torch", log_errors=True)
loader = pipe.bind(records).run("torch", log_errors=my_logger.warning)

Errors while iterating or expanding records, and Python batch-map errors, propagate directly. A Python batch map runs after the loader has consumed that batch; if it raises, checkpoint progress is not rolled back. Retrying a callback or making its external side effects transactional is the caller's responsibility.

Distributed training and resume

loader = pipe.bind(records).run(
    "torch",
    shard={"id": rank, "of": world_size, "pad": True},
    seed=42,
    concurrency=64,
)

pad=True keeps every rank at the same batch count; seed drives shuffling and native batch-transform RNG. state_dict() / load_state_dict() checkpoint and resume the loader — mid-batch resume replays the partial batch from its first sample, so transform RNG stays aligned across the restart.

Resume re-enumerates and skips the expanded source prefix; it is not a saved source cursor, shuffle buffer or partially consumed child iterator. Python loader checkpoints include a separate record_source_signature for tracked source configuration: adapter mode, ordered source transforms, shuffle settings, composition and declared CustomOp versions. This leaves the native schema 3 and existing pipeline signature unchanged. A present malformed or mismatched source signature is rejected before native restore, even at an epoch boundary. An older checkpoint without this field can resume a source with no tracked configuration; for a configured source, it requires an integer samples_consumed of zero.

Keep source contents and callback behavior unchanged. The guard does not inspect raw data, ordinary closures, hidden state or RNG progress; identically described opaque children can still be swapped without detection. Sources and callbacks must replay consistently. Expansion happens before native sharding, so each rank may enumerate upstream records and run expansion callbacks for records it does not emit; composition does not push partitioning into storage.

Mid-epoch checkpoints must come from order="submit". Completion-order delivery cannot be reconstructed from a consumed-sample count, so restoring such a checkpoint raises an error. State schema 3 records output order explicitly. Schema 2 checkpoints are accepted automatically at epoch boundaries; an older mid-epoch checkpoint needs an explicit migration after verifying it used submit order.

Direct IO

Flat verbs for scripts, evaluation, and one-shot reads:

dataio.head("s3://bucket/file.bin")
chunk = dataio.read("s3://bucket/file.bin", offset=0, size=1 << 20)
etag  = dataio.write("s3://bucket/out.bin", chunk)

dataio.exists("s3://bucket/out.bin")
dataio.ls("s3://bucket/prefix/")
dataio.glob("s3://bucket/**/*.safetensors")

For large eager reads, fill a caller-owned writable buffer instead of allocating a fresh Python bytes object:

buf = bytearray(1 << 30)
n = dataio.fetch_into("s3://bucket/checkpoint.bin", buf)
view = memoryview(buf)[:n]

Composable handles for repeated operations on one source:

src = dataio.reader("s3://bucket/shard.tar.gz")
payload = src.gunzip().tar_entry("0001.jpg").read_all()

with dataio.writer("s3://bucket/checkpoint.bin") as w:
    w.write_chunks(huge_generator())

src.read_buffer() returns a read-only buffer view that retains its native storage, avoiding the final copy into Python bytes. Use memoryview(...) or numpy.frombuffer(...) when the consumer accepts the buffer protocol.

For sequential processing, dataio.stream(uri) opens through the response headers and reads the body on demand. Its byte, line and SSE iterators share one cursor; close() cancels pending reads. Lines and SSE events have configurable 8 MiB limits. Only read_all() explicitly materializes the remaining response. Streaming never retries a body after exposing it to the caller.

Custom TLS roots use SSL_CERT_FILE, with AWS_CA_BUNDLE as a fallback. A configured PEM bundle replaces the built-in roots; invalid bundles fail clearly.

Set HTTP_PROXY, HTTPS_PROXY, or ALL_PROXY before the first network request to use an HTTP proxy. HTTP requests use forwarding; HTTPS uses CONNECT with normal origin certificate verification. Proxy URLs support Basic authentication and must use http://; HTTPS and SOCKS proxy transports fail explicitly. Lowercase variables take precedence. NO_PROXY / no_proxy accept domain suffixes, IP addresses, CIDR networks, optional ports, and *. CGI environments (REQUEST_METHOD present) ignore uppercase HTTP_PROXY.

dataio.configure_transport("https", timeout_secs=...) bounds each eager request attempt, including redirects, response headers and body. Streaming instead applies the body timeout while waiting for data, excluding caller processing time.

Large eager reads can configure range planning per scheme:

dataio.configure_transport(
    "https", timeout_secs=30, readall_chunk_mib=32, readall_concurrency=8,
)

The range defaults remain 32 MiB and 8, subject to environment overrides. readall_chunk_mib is a chunk-size floor for automatic partitioning; readall_concurrency=1 disables splitting. These settings govern each read, not aggregate memory or concurrency across readers. Small reads remain single requests, and splitting still requires a strong validator. Configuration replaces that scheme's explicit options: pass options together to retain them.

Credentials and endpoints are configured once per scheme:

dataio.configure_credentials("s3", method="default")  # platform chain
dataio.configure_credentials("r2", access_key_id="...", secret_access_key="...")
dataio.configure_endpoint("r2", "https://<account>.r2.cloudflarestorage.com")

DATAIO_CACHE_DIR enables the optional local byte cache. Object/HF cache entries are partitioned by a hash of a supported explicit credential and endpoint identity. Dynamic credential providers bypass disk caching; their in-process parsed indexes follow client configuration changes. Cache hits do not revalidate origin freshness or permissions: use immutable sources or disable the relevant caches when reading mutable objects.

method="default" resolves through env vars, a shared profile, instance metadata, or workload identity — whichever the platform exposes.

Format helpers

arr   = dataio.read_numpy("/data/x.npy")
image = dataio.read_image("s3://bucket/image.png", mode="rgb")
cols  = dataio.read_parquet("/data/shard.parquet", columns=["key", "height"])
rows  = (dataio.scan_parquet("/data/shard.parquet")
            .filter(lambda r: r["height"] > 512)
            .collect())

for example in dataio.iter_tfrecord("/data/train.tfrecord"):
    label = example["label"]

Feather / Arrow IPC scans can export Arrow data without creating Python objects for individual cells:

scan = dataio.scan_feather("/data/table.arrow").select(["key", "value"])
stream = scan.collect_arrow_stream()  # Arrow C stream protocol
table = scan.collect_arrow()          # requires optional pyarrow

These exports preserve Arrow types and decoded buffers, including projection and row slicing. collect_arrow_reader() returns a PyArrow batch reader; Python callable filters use the row-oriented collection methods instead. Native NPY decoding supports complex64 and complex128, including foreign byte order and Fortran layout.

HDF5 reads support integer indices, positive-step slices, and one ellipsis:

window = dataio.read_hdf5(
    "/data/arrays.h5", key="images", selection=(slice(10, 20), ...),
)
with dataio.open_hdf5("/data/arrays.h5") as source:
    view = source.read(key="labels", copy=False)

The default returns independent writable NumPy arrays. copy=False returns read-only output that remains valid after session close; decoding, selection, or byte-order conversion can still allocate. Contiguous compatible datasets can share the file mapping, while chunked selections decode only intersecting chunks. Remote HDF5 still downloads the whole file when opened.

safetensors

Zero-copy mmap reads for both single files and sharded checkpoints, including C64 / complex64 tensors with NumPy, PyTorch, and DLPack outputs:

NumPy views are read-only. Torch uses private copy-on-write local mappings; writable outputs from immutable in-memory or remote buffers require a copy.

dataio.write_safetensors(
    "/fsx/ckpt-step-12000/",
    state_dict,
    max_shard_size="5GB",
    metadata={"format": "pt"},
)

state_dict = dataio.read_safetensors("/fsx/ckpt-step-12000/", framework="torch")
subset = dataio.read_safetensors(
    "/fsx/ckpt-step-12000/",
    keys=["model.layers.0.weight", "model.norm.weight"],
    framework="torch",
)

with dataio.open_safetensors("/fsx/model.safetensors") as st:
    tensor = st.read(key="layer.weight", framework="torch")
    subset = st.read(keys=["layer.weight", "layer.bias"], framework="torch")

On Linux hosts with CUDA and a GDS-ready filesystem, reads land directly in device memory:

state_dict = dataio.read_safetensors(
    "/fsx/ckpt-step-12000/",
    framework="torch",
    device="cuda:0",
)

dataio.gds_available() and dataio.gds_info() report the active state.

RDMA transport

dataio.rdma is a native one-sided RDMA client + server over libfabric (OFI), built for fast peer-to-peer checkpoint transport over EFA / verbs / RoCE. It is CPU-safe: libfabric.so.1 is discovered via dlopen at first use. available() reports whether a compatible RMA provider can be opened, including tcp;ofi_rxm / sockets functional fallbacks; it does not prove physical RDMA availability. info() reports the compiled feature and discovered providers. Handles are context managers.

import dataio.rdma as rdma

with rdma.serve(bind="0.0.0.0:0", buffer_size=1 << 20) as server:
    addr = server.local_addr
    with rdma.connect(addr) as client:
        rdma.write(client, offset=0, data=b"hello rdma")
        assert rdma.read(client, offset=0, size=10) == b"hello rdma"

The data path is pipelined and zero-copy: a transfer is split into chunk_size segments with up to max_inflight posted concurrently (the useful window depends on provider, payload and network). read_into lands bytes straight into a caller-owned buffer (bytearray / numpy / pinned torch tensor / mmap) with no intermediate copy; write registers the caller's buffer directly as the RMA source.

Serving a checkpoint file needs no extra protocol — a self-describing format like safetensors works as-is, and a CUDA-connected client can pull each tensor's byte range straight into VRAM via GPUDirect RDMA:

# producer: serve weights read-only
server = rdma.serve_file("/fsx/model.safetensors", bind="0.0.0.0:0")

# consumer: GPUDirect-RDMA tensor ranges into VRAM
client = rdma.connect(server.local_addr, cuda=True)
import torch
dst = torch.empty(shape, dtype=torch.bfloat16, device="cuda:0")
rdma.read_into(client, dst, offset=tensor_byte_offset)  # NIC → VRAM, host untouched

GPUDirect needs an HMEM-capable provider and libfabric API ≥ 1.9. Rather than write a C fi_getinfo probe, run the self-diagnostic — it runs the real plain-RMA and HMEM opens and reports exactly why each would or wouldn't match:

for line in rdma.diagnose()["summary"]:
    print(line)

rdma.available() / rdma.info() give the boolean and per-provider capability snapshot.

API at a glance

API Purpose
pipeline, slot, slots, chain, batch, collate, group_by pipeline DSL
map, custom_op Python extension hooks
DataLoader synchronous batch iterator
read / fetch_into / write / head / stream / ls / glob / exists / delete URI bytes plus explicit read(format=...) materialization
reader, writer, scan composable IO handles and generic lazy scans
from_callable, from_iterable, from_iterator, from_sampler, files, urls, manifest, webdataset, archive record sources
read_safetensors, write_safetensors, open_safetensors safetensors
read_numpy, scan_numpy, read_npz, scan_npz, read_image, read_parquet, scan_parquet, read_feather, scan_feather, iter_tfrecord, scan_tfrecord, read_hdf5, scan_hdf5, open_hdf5 format helpers
configure_credentials, configure_endpoint, configure_transport auth and transport
gds_open, gds_register_buffer, gds_read_into_tensor low-level GDS
rdma.serve, rdma.serve_file, rdma.connect, rdma.read_into, rdma.diagnose RDMA transport

Documentation

Development

The Rust toolchain is pinned in rust-toolchain.toml. Editable build:

uv run --no-sync --with maturin maturin develop --profile staging

Source builds omit the optional native RDMA shim and need no libfabric headers. Add --features rdma to the maturin command to enable it; install the libfabric development headers first. Published wheels include this feature and discover the runtime provider when used. The native Rust I/O, object and format crates can be built without Python; only the root Python adapter enables the runtime's python feature.

Tests:

cargo test
uv run --no-sync python -m pytest python/tests -q

Wheel:

uv run --no-sync --with maturin maturin build --profile staging --out dist

Performance

Measure the workload and output type used by your application. Decode-heavy pipelines, object-only records, remote transfers and GPU operations have different bottlenecks. The benchmark guide provides reproducible commands, output checks and paired regression comparisons; no single workload establishes performance across all backends.

License

Apache-2.0. Source: https://github.com/Mikubill/dataio-rs. PyPI: https://pypi.org/project/dataio-rs/.

Metadata

Release files for dataio-rs 0.4.10

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for dataio-rs 0.4.10
File Size Uploaded Provenance Actions
dataio_rs-0.4.10.tar.gz 1.3 MB Without provenance Details for dataio_rs-0.4.10.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for dataio-rs 0.4.10
File Interpreter ABI Platform Actions
dataio_rs-0.4.10-cp311-abi3-manylinux_2_28_x86_64.whl CPython 3.11 abi3 Linux glibc 2.28+ x86-64 Details for dataio_rs-0.4.10-cp311-abi3-manylinux_2_28_x86_64.whl

Total release size: 14.2 MB

Release files / dataio_rs-0.4.10.tar.gz

Download URL dataio_rs-0.4.10.tar.gz
Size 1.3 MB
Tags Source
SHA-256 checksum
How to use checksums
6c7ff32c3b28e47dbabfbda8cd66d67a321b288748d6e8763663e45ad73fdfc0
BLAKE2b-256 checksum
How to use checksums
9f79de05f1a2be9c8648feb895aa7446fc1777fed8ace6378825b22cbf3fccab
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/6.1.0 CPython/3.13.12

Release files / dataio_rs-0.4.10-cp311-abi3-manylinux_2_28_x86_64.whl

Download URL dataio_rs-0.4.10-cp311-abi3-manylinux_2_28_x86_64.whl
Size 12.8 MB
Tags CPython 3.11 Linux glibc 2.28+ x86-64 abi3
SHA-256 checksum
How to use checksums
91a7e19e72726567fd249240187d7c94e336ef2d7316719766b84df9269a509f
BLAKE2b-256 checksum
How to use checksums
e67cf8797c880f1d4041dd6d460931d7c063da1485a24454f08a9f0fca9367fa
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/6.1.0 CPython/3.13.12

Security for dataio-rs 0.4.10

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page