finance-query 3.0.0

A Rust library for querying financial data
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use crate::backtesting::strategy::StrategyContext;
use crate::indicators::Indicator;

use super::IndicatorRef;

/// On-Balance Volume reference.
#[derive(Debug, Clone, Copy)]
pub struct ObvRef;

impl IndicatorRef for ObvRef {
    fn key(&self) -> &str {
        "obv"
    }

    fn required_indicators(&self) -> Vec<(String, Indicator)> {
        vec![("obv".to_string(), Indicator::Obv)]
    }

    fn value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator(self.key())
    }

    fn prev_value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator_prev(self.key())
    }
}

/// Create an On-Balance Volume reference.
#[inline]
pub fn obv() -> ObvRef {
    ObvRef
}

/// Volume Weighted Average Price reference.
#[derive(Debug, Clone, Copy)]
pub struct VwapRef;

impl IndicatorRef for VwapRef {
    fn key(&self) -> &str {
        "vwap"
    }

    fn required_indicators(&self) -> Vec<(String, Indicator)> {
        vec![("vwap".to_string(), Indicator::Vwap)]
    }

    fn value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator(self.key())
    }

    fn prev_value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator_prev(self.key())
    }
}

/// Create a Volume Weighted Average Price reference.
#[inline]
pub fn vwap() -> VwapRef {
    VwapRef
}

/// Chaikin Money Flow reference.
#[derive(Debug, Clone)]
pub struct CmfRef {
    pub period: usize,
    key: String,
}

impl IndicatorRef for CmfRef {
    fn key(&self) -> &str {
        &self.key
    }

    fn required_indicators(&self) -> Vec<(String, Indicator)> {
        vec![(self.key.clone(), Indicator::Cmf(self.period))]
    }

    fn value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator(self.key())
    }

    fn prev_value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator_prev(self.key())
    }
}

/// Create a Chaikin Money Flow reference.
#[inline]
pub fn cmf(period: usize) -> CmfRef {
    CmfRef {
        period,
        key: format!("cmf_{period}"),
    }
}

/// Accumulation/Distribution reference.
#[derive(Debug, Clone, Copy)]
pub struct AccumulationDistributionRef;

/// Create an Accumulation/Distribution reference.
#[inline]
pub fn accumulation_distribution() -> AccumulationDistributionRef {
    AccumulationDistributionRef
}

impl IndicatorRef for AccumulationDistributionRef {
    fn key(&self) -> &str {
        "ad"
    }

    fn required_indicators(&self) -> Vec<(String, Indicator)> {
        vec![("ad".to_string(), Indicator::AccumulationDistribution)]
    }

    fn value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator(self.key())
    }

    fn prev_value(&self, ctx: &StrategyContext) -> Option<f64> {
        ctx.indicator_prev(self.key())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::backtesting::refs::{balance_of_power, chaikin_oscillator, mfi};

    #[test]
    fn test_volume_keys() {
        assert_eq!(obv().key(), "obv");
        assert_eq!(vwap().key(), "vwap");
        assert_eq!(mfi(14).key(), "mfi_14");
        assert_eq!(cmf(20).key(), "cmf_20");
        assert_eq!(chaikin_oscillator().key(), "chaikin_osc");
        assert_eq!(accumulation_distribution().key(), "ad");
        assert_eq!(balance_of_power(Some(14)).key(), "bop_14");
        assert_eq!(balance_of_power(None).key(), "bop");
    }
}