jacquard-api 0.12.0-beta.2

Generated AT Protocol API bindings for Jacquard
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

// @generated by jacquard-lexicon. DO NOT EDIT.
//
// Lexicon: science.alt.dataset.arrayFormat
//
// This file was automatically generated from Lexicon schemas.
// Any manual changes will be overwritten on the next regeneration.

use jacquard_common::{BosStr, CowStr, DefaultStr, FromStaticStr};
use jacquard_derive::IntoStatic;
use serde::{Deserialize, Serialize};
/// Arrow tensor format. Stores multi-dimensional arrays using Arrow's tensor IPC format. Versions maintained at https://json-schema.alt.science/atdata-arrow-tensor/{version}/

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct ArrowTensor;
impl core::fmt::Display for ArrowTensor {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "arrowTensor")
    }
}

/// Array serialization format identifier for NDArray fields in sample schemas. Known values correspond to token definitions in this Lexicon. Each format has versioned specifications maintained by alt.science at canonical URLs.

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ArrayFormat<S: BosStr = DefaultStr> {
    NdarrayBytes,
    SparseBytes,
    StructuredBytes,
    ArrowTensor,
    Safetensors,
    Other(S),
}

impl<S: BosStr> ArrayFormat<S> {
    pub fn as_str(&self) -> &str {
        match self {
            Self::NdarrayBytes => "ndarrayBytes",
            Self::SparseBytes => "sparseBytes",
            Self::StructuredBytes => "structuredBytes",
            Self::ArrowTensor => "arrowTensor",
            Self::Safetensors => "safetensors",
            Self::Other(s) => s.as_ref(),
        }
    }
    /// Construct from a string-like value, matching known values.
    pub fn from_value(s: S) -> Self {
        match s.as_ref() {
            "ndarrayBytes" => Self::NdarrayBytes,
            "sparseBytes" => Self::SparseBytes,
            "structuredBytes" => Self::StructuredBytes,
            "arrowTensor" => Self::ArrowTensor,
            "safetensors" => Self::Safetensors,
            _ => Self::Other(s),
        }
    }
}

impl<S: BosStr> AsRef<str> for ArrayFormat<S> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<S: BosStr> core::fmt::Display for ArrayFormat<S> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<S: BosStr> Serialize for ArrayFormat<S> {
    fn serialize<Ser>(&self, serializer: Ser) -> Result<Ser::Ok, Ser::Error>
    where
        Ser: serde::Serializer,
    {
        serializer.serialize_str(self.as_str())
    }
}

impl<'de, S: Deserialize<'de> + BosStr> Deserialize<'de> for ArrayFormat<S> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let s = S::deserialize(deserializer)?;
        Ok(Self::from_value(s))
    }
}

impl<S: BosStr> jacquard_common::IntoStatic for ArrayFormat<S>
where
    S: BosStr + jacquard_common::IntoStatic,
    S::Output: BosStr,
{
    type Output = ArrayFormat<S::Output>;
    fn into_static(self) -> Self::Output {
        match self {
            ArrayFormat::NdarrayBytes => ArrayFormat::NdarrayBytes,
            ArrayFormat::SparseBytes => ArrayFormat::SparseBytes,
            ArrayFormat::StructuredBytes => ArrayFormat::StructuredBytes,
            ArrayFormat::ArrowTensor => ArrayFormat::ArrowTensor,
            ArrayFormat::Safetensors => ArrayFormat::Safetensors,
            ArrayFormat::Other(v) => ArrayFormat::Other(v.into_static()),
        }
    }
}

/// Numpy .npy binary format for NDArray serialization. Stores arrays with dtype and shape in binary header. Versions maintained at https://json-schema.alt.science/atdata-ndarray-bytes/{version}/

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct NdarrayBytes;
impl core::fmt::Display for NdarrayBytes {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "ndarrayBytes")
    }
}

/// Safetensors format (HuggingFace). Stores ML tensors with safe, memory-mapped access. Versions maintained at https://json-schema.alt.science/atdata-safetensors/{version}/

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct Safetensors;
impl core::fmt::Display for Safetensors {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "safetensors")
    }
}

/// Scipy sparse matrix format (CSR/CSC/COO). Stores sparse matrices with indices and data arrays. Versions maintained at https://json-schema.alt.science/atdata-sparse-bytes/{version}/

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct SparseBytes;
impl core::fmt::Display for SparseBytes {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "sparseBytes")
    }
}

/// Numpy structured array format. Stores arrays with named, typed fields (compound dtypes). Versions maintained at https://json-schema.alt.science/atdata-structured-bytes/{version}/

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, IntoStatic, Hash)]
pub struct StructuredBytes;
impl core::fmt::Display for StructuredBytes {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "structuredBytes")
    }
}