chroma-error 0.15.0

Chroma-provided crate for errors returned from Chroma.
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

use crate::{ChromaError, ErrorCodes};
use thiserror::Error;

impl From<ErrorCodes> for tonic::Code {
    fn from(err: ErrorCodes) -> tonic::Code {
        match err {
            ErrorCodes::Success => tonic::Code::Ok,
            ErrorCodes::Cancelled => tonic::Code::Cancelled,
            ErrorCodes::Unknown => tonic::Code::Unknown,
            ErrorCodes::InvalidArgument => tonic::Code::InvalidArgument,
            ErrorCodes::DeadlineExceeded => tonic::Code::DeadlineExceeded,
            ErrorCodes::NotFound => tonic::Code::NotFound,
            ErrorCodes::AlreadyExists => tonic::Code::AlreadyExists,
            ErrorCodes::PermissionDenied => tonic::Code::PermissionDenied,
            ErrorCodes::ResourceExhausted => tonic::Code::ResourceExhausted,
            ErrorCodes::FailedPrecondition => tonic::Code::FailedPrecondition,
            ErrorCodes::Aborted => tonic::Code::Aborted,
            ErrorCodes::OutOfRange => tonic::Code::OutOfRange,
            ErrorCodes::Unimplemented => tonic::Code::Unimplemented,
            ErrorCodes::Internal => tonic::Code::Internal,
            ErrorCodes::Unavailable => tonic::Code::Unavailable,
            ErrorCodes::DataLoss => tonic::Code::DataLoss,
            ErrorCodes::Unauthenticated => tonic::Code::Unauthenticated,
            ErrorCodes::VersionMismatch => tonic::Code::Internal,
            ErrorCodes::UnprocessableEntity => tonic::Code::ResourceExhausted,
        }
    }
}

impl From<tonic::Code> for ErrorCodes {
    fn from(code: tonic::Code) -> ErrorCodes {
        match code {
            tonic::Code::Ok => ErrorCodes::Success,
            tonic::Code::Cancelled => ErrorCodes::Cancelled,
            tonic::Code::Unknown => ErrorCodes::Unknown,
            tonic::Code::InvalidArgument => ErrorCodes::InvalidArgument,
            tonic::Code::DeadlineExceeded => ErrorCodes::DeadlineExceeded,
            tonic::Code::NotFound => ErrorCodes::NotFound,
            tonic::Code::AlreadyExists => ErrorCodes::AlreadyExists,
            tonic::Code::PermissionDenied => ErrorCodes::PermissionDenied,
            tonic::Code::ResourceExhausted => ErrorCodes::ResourceExhausted,
            tonic::Code::FailedPrecondition => ErrorCodes::FailedPrecondition,
            tonic::Code::Aborted => ErrorCodes::Aborted,
            tonic::Code::OutOfRange => ErrorCodes::OutOfRange,
            tonic::Code::Unimplemented => ErrorCodes::Unimplemented,
            tonic::Code::Internal => ErrorCodes::Internal,
            tonic::Code::Unavailable => ErrorCodes::Unavailable,
            tonic::Code::DataLoss => ErrorCodes::DataLoss,
            tonic::Code::Unauthenticated => ErrorCodes::Unauthenticated,
        }
    }
}

#[derive(Debug, Error)]
#[error("Tonic error: {0}")]
pub struct TonicError(#[from] pub tonic::Status);

impl ChromaError for TonicError {
    fn code(&self) -> ErrorCodes {
        self.0.code().into()
    }
}

impl From<tonic::Status> for Box<dyn ChromaError> {
    fn from(value: tonic::Status) -> Self {
        Box::new(TonicError(value))
    }
}

#[derive(Debug, Error)]
#[error("Field missing from gRPC response: {0}")]
pub struct TonicMissingFieldError(pub &'static str);

impl ChromaError for TonicMissingFieldError {
    fn code(&self) -> ErrorCodes {
        ErrorCodes::Internal
    }
}

pub fn status_from_chroma_error(err: impl ChromaError + std::fmt::Display) -> tonic::Status {
    tonic::Status::new(err.code().into(), err.to_string())
}