pbzarr 0.5.1

A Zarr v3 convention for per-base resolution genomic data
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

use crate::genome::Genome;
use crate::io::column::ColumnSinkMut;
use crate::io::dtype::{Dtype, Numeric};
use crate::io::error::Result;
use ndarray::ArrayViewMut2;
pub trait ValueReader: Send + Sync {
    /// The numeric type this reader produces.
    type Item: Numeric;

    /// Contigs present in the source file, with lengths.
    fn contigs(&self) -> &Genome;

    /// Number of value columns per record. Determines the trailing
    /// axis of the buffer passed to `read_into`. Scalar tracks return 1.
    fn n_fields(&self) -> usize;

    /// Fill `dst` with values for `[start, end)` on the contig named `contig_name`.
    ///
    /// The reader resolves `contig_name` in its own genome. `dst` has shape
    /// `((end - start) as usize, self.n_fields())`. The caller pre-fills `dst`
    /// with the desired fill value; the reader only overwrites positions where
    /// the source file has data.
    ///
    /// Names — not `ContigId`s — cross this boundary because `ContigId` is
    /// namespaced to its owning `Genome`. The caller's genome (e.g., a pbz
    /// store) and the reader's source file are independent.
    fn read_into(
        &self,
        contig_name: &str,
        start: u64,
        end: u64,
        dst: ArrayViewMut2<'_, Self::Item>,
    ) -> Result<()>;

    /// Produce a worker-local handle for use on a single thread.
    /// Shared state (index, header) is reused via `Arc`; per-thread
    /// state (file handle, decode buffers) is freshly allocated.
    fn fork(&self) -> Result<Self>
    where
        Self: Sized;
}

/// Multi-column analogue of [`ValueReader`]: one source fans out to several
/// tracks of possibly different dtypes in a single decode pass. Each element of
/// `columns()` is one target track's dtype, in track order; `read_into` fills
/// one [`ColumnSinkMut`] per column for the same `[start, end)` window.
pub trait MultiValueReader: Send + Sync {
    /// Contigs present in the source file, with lengths.
    fn contigs(&self) -> &Genome;

    /// Dtype of each target column/track, in order. `sinks` in `read_into`
    /// matches this length and order.
    fn columns(&self) -> &[Dtype];

    /// Fill each sink with values for `[start, end)` on the contig named
    /// `contig_name`. `sinks[i]` is already sliced to the window; the reader
    /// indexes it from 0. Positions the source does not cover are left as the
    /// caller's fill.
    fn read_into(
        &self,
        contig_name: &str,
        start: u64,
        end: u64,
        sinks: &mut [ColumnSinkMut<'_>],
    ) -> Result<()>;

    /// Worker-local handle, sharing index/header via `Arc` (see `ValueReader::fork`).
    fn fork(&self) -> Result<Self>
    where
        Self: Sized;
}