chatty-rs 0.0.1-alpha1

A terminal-based chat client for OpenAI's GPT models.
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
118
119
120
121
122
123
124
125
126
127
128
129
130

#[derive(Debug, Clone)]
pub enum Issuer {
    System(String),
    User(String),
}

#[derive(Debug, Clone)]
pub struct Message {
    id: String,
    issuer: Issuer,
    text: String,
    token_count: usize,
    created_at: chrono::DateTime<chrono::Utc>,
    /// Indicates if the message is part of a context
    context: bool,
}

impl Message {
    pub fn new(issuer: Issuer, text: impl Into<String>) -> Self {
        Self {
            id: uuid::Uuid::new_v4().to_string(),
            issuer,
            text: text.into(),
            token_count: 0,
            created_at: chrono::Utc::now(),
            context: false,
        }
    }

    pub fn new_system(system: &str, text: impl Into<String>) -> Self {
        Self::new(Issuer::System(system.to_string()), text)
    }

    pub fn new_user(user: &str, text: impl Into<String>) -> Self {
        Self::new(Issuer::User(user.to_string()), text)
    }

    pub fn with_context(mut self, context: bool) -> Self {
        if matches!(self.issuer, Issuer::System(_)) {
            self.context = context;
        }
        self
    }

    /// Indicates if the message is part of a context. Only avaiable for
    /// system messages. If backend receives a message is marked as context
    ///, it should be treated as a context message. E.g: OpenAI's role should
    /// be "system" instead of "assistant".
    pub fn is_context(&self) -> bool {
        self.context
    }

    pub fn with_id(mut self, id: impl Into<String>) -> Self {
        self.id = id.into();
        self
    }

    pub fn with_created_at(mut self, timestamp: chrono::DateTime<chrono::Utc>) -> Self {
        self.created_at = timestamp;
        self
    }

    pub fn with_text(mut self, text: impl Into<String>) -> Self {
        self.text = text.into();
        self
    }

    pub fn with_token_count(mut self, token_count: usize) -> Self {
        self.set_token_count(token_count);
        self
    }

    pub fn set_token_count(&mut self, token_count: usize) {
        self.token_count = token_count;
    }

    pub fn token_count(&self) -> usize {
        self.token_count
    }

    pub fn id(&self) -> &str {
        &self.id
    }

    pub fn is_system(&self) -> bool {
        matches!(self.issuer, Issuer::System(_))
    }

    pub fn issuer(&self) -> &Issuer {
        &self.issuer
    }

    pub fn text(&self) -> &str {
        &self.text
    }

    pub fn created_at(&self) -> chrono::DateTime<chrono::Utc> {
        self.created_at
    }

    pub fn issuer_str(&self) -> &str {
        match &self.issuer {
            Issuer::System(s) => s,
            Issuer::User(u) => u,
        }
    }

    pub fn append(&mut self, text: impl Into<String>) {
        let text = text.into();
        self.text += &text.replace('\t', "  ");
    }
}

impl Issuer {
    pub fn user() -> Self {
        Self::User("".to_string())
    }

    pub fn user_with_name(name: impl Into<String>) -> Self {
        Self::User(name.into())
    }

    pub fn system() -> Self {
        Self::System("".to_string())
    }

    pub fn system_with_name(name: impl Into<String>) -> Self {
        Self::System(name.into())
    }
}