array-format 0.9.0

A block-backed, footer-indexed container for storing multiple n-dimensional arrays in a single file, with a delta/overlay architecture and pluggable compression and storage backends.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! Error types for the array-format crate.

use crate::dtype::DType;

/// The error type for array-format operations.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// I/O error from the underlying storage backend.
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),

    /// Footer serialization or deserialization failed.
    #[error("serialization error: {0}")]
    Serialization(String),

    /// The file footer is invalid or corrupt.
    #[error("invalid footer: {0}")]
    InvalidFooter(String),

    /// The requested array was not found.
    #[error("array not found: {name}")]
    ArrayNotFound {
        /// Name of the array that was not found.
        name: String,
    },

    /// A referenced block id is out of range.
    #[error("block out of range: {block_id}")]
    BlockOutOfRange {
        /// The invalid block id.
        block_id: u32,
    },

    /// Compression or decompression failed.
    #[error("codec error: {0}")]
    Codec(String),

    /// Storage backend error.
    #[error("storage error: {0}")]
    Storage(String),

    /// The array already exists.
    #[error("array already exists: {name}")]
    ArrayAlreadyExists {
        /// Name of the duplicate array.
        name: String,
    },

    /// The dtype of the data does not match the dtype of the array.
    #[error("dtype mismatch: expected {expected:?}, got {actual:?}")]
    DTypeMismatch {
        /// The dtype declared in the array metadata.
        expected: DType,
        /// The dtype of the data being read or written.
        actual: DType,
    },
}

/// A specialized [`Result`] type for array-format operations.
pub type Result<T> = std::result::Result<T, Error>;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn error_display() {
        let e = Error::ArrayNotFound {
            name: "temp".into(),
        };
        assert_eq!(e.to_string(), "array not found: temp");
    }

    #[test]
    fn io_error_conversion() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "gone");
        let e: Error = io_err.into();
        assert!(matches!(e, Error::Io(_)));
    }
}