Struct H5Attribute 

pub struct H5Attribute { /* private fields */ }

A handle to an HDF5 attribute.

After creating an attribute via AttrBuilder::create, use write_scalar or write_string to set its value.

In read mode, use read_string to read string attributes.

Implementations

impl H5Attribute

pub fn name(&self) -> &str

Return the attribute name.

pub fn write_scalar(&self, value: &VarLenUnicode) -> Result<()>

Write a scalar value to the attribute.

For VarLenUnicode, this writes a variable-length UTF-8 string attribute — the string is stored in a global heap and h5py reads it back as a Python str (matching the VarLenUnicode type name).

pub fn write_string(&self, value: &str) -> Result<()>

Write a string value to the attribute (convenience method).

pub fn write_string_array(&self, values: &[&str]) -> Result<()>

Write a variable-length UTF-8 string array attribute.

The attribute must have been given a 1-D shape via AttrBuilder::shape whose single dimension equals values.len(). Every element is stored in one shared global heap collection; h5py reads the attribute back as a 1-D array of Python str. The string-array counterpart of write_string / write_array.

pub fn write_numeric<T: H5Type>(&self, value: &T) -> Result<()>

Write a numeric scalar attribute.

let file = H5File::create("num_attr.h5").unwrap();
let ds = file.new_dataset::<f32>().shape(&[10]).create("data").unwrap();
ds.write_raw(&[0.0f32; 10]).unwrap();
let attr = ds.new_attr::<f64>().shape(()).create("scale").unwrap();
attr.write_numeric(&3.14f64).unwrap();

pub fn write_array<T: H5Type>(&self, values: &[T]) -> Result<()>

Write a numeric array attribute.

The number of values must equal the product of the dimensions set via AttrBuilder::shape; if no shape was set the attribute is a scalar and exactly one value is required. The on-disk datatype is T::hdf5_type() and the dataspace is the simple dataspace described by the shape — matching the 1-D int32 array attributes AreaDetector writes (e.g. NDArrayDimOffset, Binning, Reverse).

let file = H5File::create("arr_attr.h5").unwrap();
let ds = file.new_dataset::<f32>().shape(&[10]).create("data").unwrap();
ds.write_raw(&[0.0f32; 10]).unwrap();
let attr = ds.new_attr::<i32>().shape([3]).create("dim_offset").unwrap();
attr.write_array(&[0i32, 4, 8]).unwrap();

pub fn read_numeric<T: H5Type>(&self) -> Result<T>

Read a numeric scalar attribute.

let file = H5File::open("num_attr.h5").unwrap();
let ds = file.dataset("data").unwrap();
let attr = ds.attr("scale").unwrap();
let val: f64 = attr.read_numeric().unwrap();

pub fn read_string(&self) -> Result<String>

Read the attribute value as a string.

Handles both fixed-length string attributes and variable-length string attributes (h5py’s default), resolving a vlen value through the global heap.

pub fn datatype(&self) -> Result<DatatypeMessage>

Return the attribute datatype as parsed from the file (read mode only).

Mirrors H5Dataset::datatype: it exposes the full datatype — class (integer vs floating-point vs string vs compound …), signedness, byte order and bit precision — so callers mapping an attribute to a NumPy / Arrow dtype need not infer a type from the byte width, which cannot distinguish u8 from i8 (both 1 byte) or i32 from f32 (both 4 bytes).

Errors

Returns an error for a write-mode handle, which carries no decoded attribute message.

let file = H5File::open("data.h5").unwrap();
let ds = file.dataset("image").unwrap();
let attr = ds.attr("scale").unwrap();
match attr.datatype().unwrap() {
    DatatypeMessage::FloatingPoint { size, .. } => println!("float: {size} bytes"),
    other => println!("other type: {other}"),
}

pub fn read_raw(&self) -> Result<Vec<u8>>

Read the raw attribute data bytes.