zarrs_metadata_ext 0.4.4

Zarr extensions metadata support for the zarrs crate
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! `rectilinear` chunk grid metadata.

use std::num::NonZeroU64;

use derive_more::Display;
use serde::{Deserialize, Serialize};

use zarrs_metadata::ConfigurationSerialize;

/// Configuration parameters for a `rectilinear` chunk grid.
#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug, Display)]
#[serde(tag = "kind", rename_all = "lowercase")]
#[display("{}", serde_json::to_string(self).unwrap_or_default())]
pub enum RectilinearChunkGridConfiguration {
    /// Inline chunk shape specification.
    Inline {
        /// The chunk edge lengths per dimension.
        chunk_shapes: Vec<ChunkEdgeLengths>,
    },
}

impl ConfigurationSerialize for RectilinearChunkGridConfiguration {}

/// An element in run-length encoded chunk configuration.
///
/// This is a run-length encoded representation of chunk sizes for a dimension.
/// Each element is either a single value or a pair [value, count].
#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug, derive_more::From)]
#[serde(untagged)]
pub enum RunLengthElement {
    /// A pair [value, count] representing `count` repetitions of `value`.
    Repeated([NonZeroU64; 2]),
    /// A single value.
    Single(NonZeroU64),
}

/// Chunk edge lengths for a dimension in a rectilinear chunk grid.
///
/// Can be specified as either:
/// - A scalar integer representing a regular grid of fixed-size chunks
/// - An array of integers (potentially run-length encoded) representing varying chunk sizes
#[derive(Serialize, Deserialize, Clone, Eq, PartialEq, Debug, derive_more::From)]
#[serde(untagged)]
pub enum ChunkEdgeLengths {
    /// A scalar value representing a regular grid with fixed-size chunks.
    Scalar(NonZeroU64),
    /// An array of chunk edge lengths (potentially run-length encoded).
    Varying(Vec<RunLengthElement>),
}

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

    #[test]
    fn rectilinear_spec_example() {
        let json = r#"
        {
            "kind": "inline",
            "chunk_shapes": [
                4,
                [1, 2, 3],
                [[4, 2]],
                [[1, 3], 3],
                [4, 4, 4]
            ]
        }"#;
        let _config: RectilinearChunkGridConfiguration = serde_json::from_str(json).unwrap();
    }

    #[test]
    fn rectilinear_scalar_chunk_shapes() {
        // Test from the updated spec showing scalar integers
        let json = r#"
        {
            "kind": "inline",
            "chunk_shapes": [
                4,
                [1, 2, 3],
                [[4, 2]],
                [[1, 3], 3],
                [4, 4, 4]
            ]
        }"#;
        let config: RectilinearChunkGridConfiguration = serde_json::from_str(json).unwrap();

        let RectilinearChunkGridConfiguration::Inline { chunk_shapes } = &config;
        assert_eq!(chunk_shapes.len(), 5);

        // First dimension should be scalar
        assert!(matches!(&chunk_shapes[0], ChunkEdgeLengths::Scalar(v) if v.get() == 4));

        // Second dimension should be array
        assert!(matches!(&chunk_shapes[1], ChunkEdgeLengths::Varying(_)));
    }

    #[test]
    fn rectilinear_mixed_scalar_and_array() {
        let json = r#"
        {
            "kind": "inline",
            "chunk_shapes": [10, [5, 5]]
        }"#;
        let config: RectilinearChunkGridConfiguration = serde_json::from_str(json).unwrap();

        let RectilinearChunkGridConfiguration::Inline { chunk_shapes } = &config;
        assert_eq!(chunk_shapes.len(), 2);
        assert!(matches!(&chunk_shapes[0], ChunkEdgeLengths::Scalar(v) if v.get() == 10));
        assert!(matches!(&chunk_shapes[1], ChunkEdgeLengths::Varying(_)));
    }
}