aipack 0.8.23

Command Agent runner to accelerate production coding with genai.
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

// file: src/event/one_shot.rs
//! One-shot channel implementation using flume::bounded(1).
//!
//! Follows the same pattern as `unbound.rs` for consistency.
//! Senders and receivers are consumed on use, as is typical for one-shot channels.
//!
//! Example wraping the Tex
//! ```rust
//! #[derive(Clone, From, Deref)]
//! pub struct RunDoneTx(OneShotTx<RunResponse>);
//! ```

use crate::{Error, Result};

/// Create a new one-shot channel.
/// - `name` - The static name of the channel (for better error reporting).
#[allow(unused)]
pub fn new_one_shot_channel<T>(name: &'static str) -> (OneShotTx<T>, OneShotRx<T>) {
	let (tx, rx) = flume::bounded(1);
	(OneShotTx(tx, name), OneShotRx(rx, name))
}

// region:    --- OneShotTx

/// OneShot Sender with channel name.
/// Consumed on send.
#[derive(Debug, Clone)]
pub struct OneShotTx<T>(flume::Sender<T>, &'static str);

impl<T> OneShotTx<T> {
	/// Asynchronous send (preferred). Consumes the sender.
	pub async fn send(self, value: impl Into<T>) -> Result<()> {
		self.0.send_async(value.into()).await.map_err(|err| Error::ChannelTx {
			name: self.1,
			cause: err.to_string(),
		})
	}

	/// Synchronous send (`_sync` suffix for clarity). Consumes the sender.
	#[allow(unused)]
	pub fn send_sync(self, value: impl Into<T>) -> Result<()> {
		self.0.send(value.into()).map_err(|err| Error::ChannelTx {
			name: self.1,
			cause: err.to_string(),
		})
	}
}

// endregion: --- OneShotTx

// region:    --- OneShotRx

/// OneShot Receiver with channel name.
/// Consumed on receive.
pub struct OneShotRx<T>(flume::Receiver<T>, &'static str);

#[allow(unused)]
impl<T> OneShotRx<T> {
	/// Asynchronous receive (preferred). Consumes the receiver.
	pub async fn recv(self) -> Result<T> {
		self.0.recv_async().await.map_err(|err| Error::ChannelRx {
			name: self.1,
			cause: err.to_string(),
		})
	}

	/// Synchronous receive (`_sync` suffix for clarity). Consumes the receiver.
	pub fn recv_sync(self) -> Result<T> {
		self.0.recv().map_err(|err| Error::ChannelRx {
			name: self.1,
			cause: err.to_string(),
		})
	}
}

// endregion: --- OneShotRx