genai 0.3.5

Multi-AI Providers Library for Rust. (OpenAI, Gemini, Anthropic, xAI, Ollama, Groq, DeepSeek, Grok)
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

//! Some assert convenient functions

use std::convert::Into;
use std::fmt::Formatter;

pub fn assert_contains<'a, T>(data: T, val: &str)
where
	T: Into<DataContainer<'a>>,
{
	let container: DataContainer = data.into();
	assert!(
		container.contains(val),
		"Should contain: {}\nBut was: {:?}",
		val,
		container
	);
}

pub fn assert_not_contains<'a, T>(data: T, val: &str)
where
	T: Into<DataContainer<'a>>,
{
	let container: DataContainer = data.into();
	assert!(
		!container.contains(val),
		"Should not contain: {}\nBut was: {:?}",
		val,
		container
	);
}

// region:    --- Support Types

pub enum DataContainer<'a> {
	Owned(Vec<&'a str>),
	Slice(&'a [&'a str]),
	Str(&'a str),
}

impl std::fmt::Debug for DataContainer<'_> {
	fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
		match self {
			DataContainer::Owned(vec) => write!(f, "{:?}", vec),
			DataContainer::Slice(slice) => write!(f, "{:?}", slice),
			DataContainer::Str(s) => {
				write!(f, "{s}")
			}
		}
	}
}

impl<'a> From<&'a [&'a str]> for DataContainer<'a> {
	fn from(slice: &'a [&'a str]) -> Self {
		DataContainer::Slice(slice)
	}
}

impl<'a> From<&'a Vec<&'a str>> for DataContainer<'a> {
	fn from(vec: &'a Vec<&'a str>) -> Self {
		DataContainer::Slice(&vec[..])
	}
}

impl<'a> From<&'a Vec<String>> for DataContainer<'a> {
	fn from(vec: &'a Vec<String>) -> Self {
		DataContainer::Owned(vec.iter().map(|s| s.as_str()).collect())
	}
}

impl<'a> From<&'a str> for DataContainer<'a> {
	fn from(string: &'a str) -> Self {
		DataContainer::Str(string)
	}
}

impl<'a> From<&'a String> for DataContainer<'a> {
	fn from(string: &'a String) -> Self {
		DataContainer::Str(string)
	}
}

impl DataContainer<'_> {
	fn contains(&self, val: &str) -> bool {
		match self {
			DataContainer::Owned(vec) => vec.contains(&val),
			DataContainer::Slice(slice) => slice.contains(&val),
			DataContainer::Str(string) => string.contains(val),
		}
	}
}

// endregion: --- Support Types

// region:    --- Tests

#[cfg(test)]
mod tests {
	type Result<T> = core::result::Result<T, Box<dyn std::error::Error>>; // For tests.

	use super::*;

	#[test]
	fn test_assert_contains() -> Result<()> {
		let data_vec = vec!["apple", "banana", "cherry"];
		assert_contains(&data_vec, "banana");

		let data_slice: &[&str] = &["dog", "cat", "mouse"];
		assert_contains(data_slice, "cat");

		let data_str = "This is a test string";
		assert_contains(data_str, "test");

		Ok(())
	}
}

// endregion: --- Tests