systemprompt-models 0.1.22

Shared data models and types for systemprompt.io OS
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

//! Verbosity level configuration.

use super::Environment;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VerbosityLevel {
    Quiet,
    Normal,
    Verbose,
    Debug,
}

impl VerbosityLevel {
    pub const fn from_environment(env: Environment) -> Self {
        match env {
            Environment::Development => Self::Verbose,
            Environment::Production => Self::Quiet,
            Environment::Test => Self::Normal,
        }
    }

    pub fn from_env_var() -> Option<Self> {
        if std::env::var("SYSTEMPROMPT_QUIET").ok().as_deref() == Some("1") {
            return Some(Self::Quiet);
        }

        if std::env::var("SYSTEMPROMPT_VERBOSE").ok().as_deref() == Some("1") {
            return Some(Self::Verbose);
        }

        if std::env::var("SYSTEMPROMPT_DEBUG").ok().as_deref() == Some("1") {
            return Some(Self::Debug);
        }

        if let Ok(level) = std::env::var("SYSTEMPROMPT_LOG_LEVEL") {
            return match level.to_lowercase().as_str() {
                "quiet" => Some(Self::Quiet),
                "normal" => Some(Self::Normal),
                "verbose" => Some(Self::Verbose),
                "debug" => Some(Self::Debug),
                _ => None,
            };
        }

        None
    }

    pub fn resolve() -> Self {
        if let Some(level) = Self::from_env_var() {
            return level;
        }

        let env = Environment::detect();
        Self::from_environment(env)
    }

    pub const fn is_quiet(&self) -> bool {
        matches!(self, Self::Quiet)
    }

    pub const fn is_verbose(&self) -> bool {
        matches!(self, Self::Verbose | Self::Debug)
    }

    pub const fn should_show_verbose(&self) -> bool {
        matches!(self, Self::Verbose | Self::Debug)
    }

    pub const fn should_log_to_db(&self) -> bool {
        !matches!(self, Self::Quiet)
    }
}