moabdb 0.1.1

A Rust client for the MoabDB database
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

#[doc = include_str!("../README.md")]

const API_URL: &str = "https://api.moabdb.com/request/v1/";

use polars::prelude::DataFrame;

pub mod credentials;
pub mod errors;
mod protocol;
pub mod window;

/// Get the equity data for a given ticker
/// # Arguments
/// * `ticker` - The ticker symbol of the equity
/// * `window` - The window of time to get data for. Build a window with the `WindowBuilder`
/// * `intraday` - Whether to get intraday data or daily data
/// * `credentials` - The credentials to use to authenticate the request. If None, the request will be unauthenticated
///
/// # Returns
/// A `DataFrame` containing the equity data
///
/// # Examples
/// ```rust
/// use moabdb::{get_equity, window::WindowBuilder, window::WindowLength, credentials::Credentials};
///
/// let window = WindowBuilder::new()
///     .length(WindowLength::Months(3))
///     .build()
///     .unwrap();
///
/// let df = get_equity("AAPL", window, false, None).unwrap();
/// println!("{:?}", df);
/// ```
///
pub fn get_equity(
    ticker: impl AsRef<str>,
    window: window::Window,
    intraday: bool,
    credentials: Option<credentials::Credentials>,
) -> Result<DataFrame, errors::MoabError> {
    use polars::prelude::{ParquetReader, SerReader};

    let datatype = if intraday {
        "intraday_stocks"
    } else {
        "daily_stocks"
    };
    let req = protocol::Request {
        symbol: ticker.as_ref().to_string(),
        start: window.start.timestamp() as u32,
        end: window.end.timestamp() as u32,
        datatype: datatype.to_string(),
        username: match credentials {
            Some(ref creds) => creds.username.to_string(),
            None => "".to_string(),
        },
        token: match credentials {
            Some(ref creds) => creds.token.to_string(),
            None => "".to_string(),
        },
    };
    let req = req.b64();

    let mut resp = match ureq::get(API_URL).set("x-req", &req).call() {
        Ok(resp) => resp.into_reader(),
        Err(_) => return Err(errors::MoabError::TransportError),
    };

    // Read the resp to end
    let mut buffer = Vec::new();
    match resp.read_to_end(&mut buffer) {
        Ok(_) => (),
        Err(_) => return Err(errors::MoabError::TransportError),
    }
    let resp = match String::from_utf8(buffer) {
        Ok(resp) => resp,
        Err(_) => return Err(errors::MoabError::TransportError),
    };

    let resp: protocol::Response = match resp.try_into() {
        Ok(resp) => resp,
        Err(_) => return Err(errors::MoabError::TransportError),
    };

    match resp.code {
        200 => (),
        400 => return Err(errors::MoabError::RequestError),
        401 => return Err(errors::MoabError::Unauthorized),
        404 => return Err(errors::MoabError::NotFound),
        500 => return Err(errors::MoabError::ServerInternalError),
        _ => return Err(errors::MoabError::UnknownError),
    }
    let df = ParquetReader::new(std::io::Cursor::new(resp.data));
    let df = match df.finish() {
        Ok(df) => df,
        Err(_) => return Err(errors::MoabError::TransportError),
    };

    Ok(df)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn equity_sync() {
        let window = window::WindowBuilder::new()
            .length(window::WindowLength::Years(3))
            .build()
            .unwrap();
        let df = get_equity("AAPL", window, false, None).unwrap();
        println!("{:?}", df);
    }
}