ant-cli 0.5.2

CLI client for the Autonomi network
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

// Copyright 2025 MaidSafe.net limited.
//
// This SAFE Network Software is licensed to you under The General Public License (GPL), version 3.
// Unless required by applicable law or agreed to in writing, the SAFE Network Software distributed
// under the GPL Licence is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. Please review the Licences for the specific language governing
// permissions and limitations relating to use of the SAFE Network Software.

/// Analysis error display variants - simplified mapping from AnalysisError
#[derive(Debug, Clone, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum AnalysisErrorDisplay {
    UnrecognizedInput,
    FailedGet,
    // GetError variants expanded
    InvalidDataMap,
    Decryption,
    Deserialization,
    Network(NetworkErrorDisplay),
    Protocol,
    RecordNotFound,
    RecordKindMismatch,
    Configuration,
    UnrecognizedDataMap,
    TooLargeForMemory,
}

impl AnalysisErrorDisplay {
    /// Map an AnalysisError to an AnalysisErrorDisplay variant
    pub fn from_analysis_error(error: &autonomi::client::analyze::AnalysisError) -> Self {
        use autonomi::client::GetError;
        use autonomi::client::analyze::AnalysisError;

        match error {
            AnalysisError::UnrecognizedInput => Self::UnrecognizedInput,
            AnalysisError::FailedGet => Self::FailedGet,
            AnalysisError::GetError(get_error) => match get_error {
                GetError::InvalidDataMap(_) => Self::InvalidDataMap,
                GetError::Decryption(_) => Self::Decryption,
                GetError::Deserialization(_) => Self::Deserialization,
                GetError::Network(network_error) => {
                    Self::Network(NetworkErrorDisplay::from_network_error(network_error))
                }
                GetError::Protocol(_) => Self::Protocol,
                GetError::RecordNotFound => Self::RecordNotFound,
                GetError::RecordKindMismatch(_) => Self::RecordKindMismatch,
                GetError::Configuration(_) => Self::Configuration,
                GetError::UnrecognizedDataMap(_) => Self::UnrecognizedDataMap,
                GetError::TooLargeForMemory(_) => Self::TooLargeForMemory,
            },
        }
    }
}

/// Network error display variants - simplified mapping from NetworkError
#[derive(Debug, Clone, serde::Serialize)]
#[serde(rename_all = "snake_case")]
pub enum NetworkErrorDisplay {
    NetworkDriverOffline,
    NetworkDriverReceive,
    IncompatibleNetworkProtocol,
    InvalidNonZeroUsize,
    GetClosestPeersTimeout,
    InsufficientPeers,
    PutRecordMissingTargets,
    PutRecordVerification,
    PutRecordQuorumFailed,
    PutRecordTooManyPeerFailed,
    PutRecordTimeout,
    PutRecordRejected,
    OutdatedRecordRejected,
    GetQuoteError,
    InvalidQuote,
    InsufficientQuotes,
    SplitRecord,
    GetRecordTimeout,
    GetRecordQuorumFailed,
    GetRecordError,
    GetVersionError,
    InvalidRetryStrategy,
    InvalidNodeMerkleCandidate,
    TopologyVerificationFailed,
}

impl NetworkErrorDisplay {
    /// Map a NetworkError to a NetworkErrorDisplay variant
    pub fn from_network_error(error: &autonomi::networking::NetworkError) -> Self {
        use autonomi::networking::NetworkError;

        match error {
            NetworkError::NetworkDriverOffline => Self::NetworkDriverOffline,
            NetworkError::NetworkDriverReceive(_) => Self::NetworkDriverReceive,
            NetworkError::IncompatibleNetworkProtocol => Self::IncompatibleNetworkProtocol,
            NetworkError::InvalidNonZeroUsize(_) => Self::InvalidNonZeroUsize,
            NetworkError::GetClosestPeersTimeout => Self::GetClosestPeersTimeout,
            NetworkError::InsufficientPeers { .. } => Self::InsufficientPeers,
            NetworkError::PutRecordMissingTargets => Self::PutRecordMissingTargets,
            NetworkError::PutRecordVerification(_) => Self::PutRecordVerification,
            NetworkError::PutRecordQuorumFailed(_, _) => Self::PutRecordQuorumFailed,
            NetworkError::PutRecordTooManyPeerFailed(_, _) => Self::PutRecordTooManyPeerFailed,
            NetworkError::PutRecordTimeout(_) => Self::PutRecordTimeout,
            NetworkError::PutRecordRejected(_) => Self::PutRecordRejected,
            NetworkError::OutdatedRecordRejected { .. } => Self::OutdatedRecordRejected,
            NetworkError::GetQuoteError(_) => Self::GetQuoteError,
            NetworkError::InvalidQuote(_) => Self::InvalidQuote,
            NetworkError::InsufficientQuotes { .. } => Self::InsufficientQuotes,
            NetworkError::SplitRecord(_) => Self::SplitRecord,
            NetworkError::GetRecordTimeout(_) => Self::GetRecordTimeout,
            NetworkError::GetRecordQuorumFailed { .. } => Self::GetRecordQuorumFailed,
            NetworkError::GetRecordError(_) => Self::GetRecordError,
            NetworkError::GetVersionError(_) => Self::GetVersionError,
            NetworkError::InvalidRetryStrategy => Self::InvalidRetryStrategy,
            NetworkError::InvalidNodeMerkleCandidate(_) => Self::InvalidNodeMerkleCandidate,
            NetworkError::TopologyVerificationFailed { .. } => Self::TopologyVerificationFailed,
        }
    }
}