napali 0.1.1

TUI interface for Integrated Reasoning's accelerated solver API
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

#![allow(clippy::redundant_closure_call)]
#![allow(clippy::needless_lifetimes)]
#![allow(clippy::match_single_binding)]
#![allow(clippy::clone_on_copy)]

use serde::Serialize;

#[doc = "... "]
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
pub struct ApiKey(String);
impl std::ops::Deref for ApiKey {
  type Target = String;
  fn deref(&self) -> &String {
    &self.0
  }
}
impl From<ApiKey> for String {
  fn from(value: ApiKey) -> Self {
    value.0
  }
}
impl From<&ApiKey> for ApiKey {
  fn from(value: &ApiKey) -> Self {
    value.clone()
  }
}
impl std::str::FromStr for ApiKey {
  type Err = &'static str;
  fn from_str(value: &str) -> Result<Self, &'static str> {
    if value.len() > 40usize {
      return Err("longer than 40 characters");
    }
    if value.len() < 40usize {
      return Err("shorter than 40 characters");
    }
    if regress::Regex::new("[0-9a-zA-Z]{40}")
      .unwrap()
      .find(value)
      .is_none()
    {
      return Err("doesn't match pattern \"[0-9a-zA-Z]{40}\"");
    }
    Ok(Self(value.to_string()))
  }
}
impl std::convert::TryFrom<&str> for ApiKey {
  type Error = &'static str;
  fn try_from(value: &str) -> Result<Self, &'static str> {
    value.parse()
  }
}
impl std::convert::TryFrom<&String> for ApiKey {
  type Error = &'static str;
  fn try_from(value: &String) -> Result<Self, &'static str> {
    value.parse()
  }
}
impl std::convert::TryFrom<String> for ApiKey {
  type Error = &'static str;
  fn try_from(value: String) -> Result<Self, &'static str> {
    value.parse()
  }
}
impl<'de> serde::Deserialize<'de> for ApiKey {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: serde::Deserializer<'de>,
  {
    String::deserialize(deserializer)?
      .parse()
      .map_err(|e: &'static str| {
        <D::Error as serde::de::Error>::custom(e.to_string())
      })
  }
}