openai-client-cli 0.1.1

OpenAI API client CLI
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

use crate::{Entry, Error, Result, traits::*};
use std::str::FromStr;
use tracing::{debug, info};

/// The HTTP method for the API request.
pub struct Method(http::Method);

impl Method {
  /// CONNECT method.
  pub const CONNECT: Method = Method(http::Method::CONNECT);
  /// DELETE method.
  pub const DELETE: Method = Method(http::Method::DELETE);
  /// GET method.
  /// 
  /// If the API request parameters (body) are not provided, this method is preferred.
  pub const GET: Method = Method(http::Method::GET);
  /// HEAD method.
  pub const HEAD: Method = Method(http::Method::HEAD);
  /// OPTIONS method.
  pub const OPTIONS: Method = Method(http::Method::OPTIONS);
  /// PATCH method.
  pub const PATCH: Method = Method(http::Method::PATCH);
  /// POST method.
  pub const POST: Method = Method(http::Method::POST);
  /// PUT method.
  pub const PUT: Method = Method(http::Method::PUT);
  /// TRACE method.
  pub const TRACE: Method = Method(http::Method::TRACE);

  fn post_fetch_ok(self, source: &str) -> Result<Self> {
    info!(
      "Successfully fetched the API request method from {}: {:?}",
      source, self.value_ref(),
    );
    Ok(self)
  }
}

impl FromStr for Method {
  type Err = Error;

  fn from_str(name: &str) -> Result<Self> {
    Ok(Self(http::Method::from_str(name)?))
  }
}

impl Loader<http::Method> for Method {
  fn fetch(entry: &Entry) -> Result<Self> {
    let source_ok = "the program arguments";
    match entry.method
      .as_ref()
      .ok_or(Error::msg("Not provided"))
      .and_then(Method::try_from)
    {
      Ok(method) => method.post_fetch_ok(source_ok),
      Err(err) => {
        debug!("Failed to obtain the API request method from {source_ok}: {err:?}");
        let (method, dep_status) = if entry._parameter.is_some() {
          (Self::POST, "")
        } else {
          (Self::GET, "un")
        };
        debug!("The API request parameters were fetched {dep_status}successfully");
        method.post_fetch_ok("the fallback options")
      },
    }
  }
  fn value(self) -> http::Method {
    self.0
  }
  fn value_ref(&self) -> &http::Method {
    &self.0
  }
}

impl From<http::Method> for Method {
  fn from(method: http::Method) -> Self {
    Self(method)
  }
}

impl From<&http::Method> for Method {
  fn from(method: &http::Method) -> Self {
    Self(method.clone())
  }
}

impl TryFrom<&str> for Method {
  type Error = Error;

  fn try_from(text: &str) -> Result<Self> {
    Self::from_str(text)
  }
}

impl TryFrom<String> for Method {
  type Error = Error;

  fn try_from(text: String) -> Result<Self> {
    Self::from_str(&text)
  }
}

impl TryFrom<&String> for Method {
  type Error = Error;

  fn try_from(text: &String) -> Result<Self> {
    Self::from_str(text)
  }
}