espionox 0.1.42

A library for creating multi-agent workflows in Rust
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

use crate::errors::error_chain_fmt;
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};

pub type FunctionResult<T> = Result<T, FunctionError>;
#[derive(thiserror::Error)]
pub enum FunctionError {
    #[error(transparent)]
    Parser(#[from] ParserError),
    Lexer(#[from] LexerError),
}

impl Debug for FunctionError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        error_chain_fmt(self, f)
    }
}

impl Display for FunctionError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        let display = match self {
            Self::Parser(err) => err.to_string(),
            Self::Lexer(err) => err.to_string(),
        };
        write!(f, "{}", display)
    }
}

pub type ParserResult<T> = Result<T, ParserError>;
#[derive(thiserror::Error)]
pub enum ParserError {
    #[error(transparent)]
    Undefined(#[from] anyhow::Error),
    MissingField(String),
    ParamNotFound(String),
    UnexpectedToken,
    NextTokenIsNone,
}

impl Debug for ParserError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        error_chain_fmt(self, f)
    }
}

impl Display for ParserError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        let display = match self {
            Self::Undefined(err) => err.to_string(),
            Self::UnexpectedToken => "Unexpected Token".to_string(),
            Self::NextTokenIsNone => "Next Token Is None".to_string(),
            Self::MissingField(field) => format!("Missing Field: {}", field),
            Self::ParamNotFound(param) => format!("Param not found: {}", param),
        };
        write!(f, "{}", display)
    }
}

pub type LexerResult<T> = Result<T, LexerError>;
#[derive(thiserror::Error)]
pub enum LexerError {
    #[error(transparent)]
    Undefined(#[from] anyhow::Error),
    CouldNotCoerceToToken(String),
}

impl Debug for LexerError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        error_chain_fmt(self, f)
    }
}

impl Display for LexerError {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        let display = match self {
            Self::Undefined(err) => err.to_string(),
            Self::CouldNotCoerceToToken(tok) => format!("Could not coerce to token: {:?}", tok),
        };
        write!(f, "{}", display)
    }
}