easytradeview 0.2.0

A Rust-based wrapper library for the TradingView website's API, providing easy access to live trading data and indicators without requiring login credentials.
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 anyhow::{anyhow, Result};

#[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub enum Interval {
    Undefined(String),
    Min1,
    Min5,
    Min15,
    Min30,
    Hour1,
    Hour2,
    Hour4,
    Day1,
    Week1,
    Month1,
}

impl Interval {
    /// Create an undefined interval.
    pub fn undefined(s: &str) -> Interval {
        Interval::Undefined(s.to_owned())
    }

    /// Parses an interval from a string.
    pub fn parse(s: &str) -> Result<Interval> {
        match s {
            "1" | "1m" => Ok(Interval::Min1),
            "5" | "5m" => Ok(Interval::Min5),
            "15" | "15m" => Ok(Interval::Min15),
            "60" | "1h" => Ok(Interval::Hour1),
            "120" | "2h" => Ok(Interval::Hour2),
            "240" | "4h" => Ok(Interval::Hour4),
            "1d" => Ok(Interval::Day1),
            "1W" => Ok(Interval::Week1),
            "1M" => Ok(Interval::Month1),
            _ => Err(anyhow!("Invalid interval: {}", s)),
        }
    }

    /// Parses an interval from a string, or return the undefined interval if it fails.
    pub fn parse_undefined(s: &str) -> Interval {
        Self::parse(s).unwrap_or(Self::undefined(s))
    }

    /// Get the string representation of the interval as a suffix for a field.
    pub fn as_field_suffix(&self) -> String {
        match self {
            Interval::Day1 => "".to_owned(),
            _ => "|".to_owned() + self.as_ref(),
        }
    }

    pub fn all_intervals() -> &'static [Interval] {
        &[
            Interval::Min1,
            Interval::Min5,
            Interval::Min15,
            Interval::Min30,
            Interval::Hour1,
            Interval::Hour2,
            Interval::Hour4,
            Interval::Day1,
            Interval::Week1,
            Interval::Month1,
        ]
    }
}

impl Default for Interval {
    fn default() -> Self {
        Self::Day1
    }
}

impl AsRef<str> for Interval {
    fn as_ref(&self) -> &str {
        match self {
            Interval::Undefined(x) => x,
            Interval::Min1 => "1",
            Interval::Min5 => "5",
            Interval::Min15 => "15",
            Interval::Min30 => "30",
            Interval::Hour1 => "60",
            Interval::Hour2 => "120",
            Interval::Hour4 => "240",
            Interval::Day1 => "1d",
            Interval::Week1 => "1W",
            Interval::Month1 => "1M",
        }
    }
}

impl std::fmt::Display for Interval {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        let s = match self {
            Interval::Undefined(x) => x,
            Interval::Min1 => "1m",
            Interval::Min5 => "5m",
            Interval::Min15 => "15m",
            Interval::Min30 => "30m",
            Interval::Hour1 => "1h",
            Interval::Hour2 => "2h",
            Interval::Hour4 => "4h",
            Interval::Day1 => "1d",
            Interval::Week1 => "1w",
            Interval::Month1 => "1M",
        };
        write!(f, "{}", s)
    }
}