chapaty 0.1.4

A software to backtest trading strategies.
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

use crate::{
    chapaty,
    enums::column_names::{DataProviderColumnKind, VolumeProfileColumnKind},
    lazy_frame_operations::closures::round,
};
use polars::{
    lazy::dsl::GetOutput,
    prelude::{col, DataFrame, IntoLazy},
};
use rayon::{iter::ParallelIterator, prelude::IntoParallelIterator};

pub struct AggTradesVolume {}

impl AggTradesVolume {
    pub fn new() -> Self {
        Self {}
    }

    pub fn from_df_map(
        &self,
        df_map: chapaty::types::DataFrameMap,
    ) -> chapaty::types::DataFrameMap {
        df_map
            .into_par_iter()
            .map(|(key, df)| (key, self.vol_profile(df)))
            .collect()
    }

    fn vol_profile(&self, df: DataFrame) -> DataFrame {
        let px = DataProviderColumnKind::Price.to_string();
        let qx = DataProviderColumnKind::Quantity.to_string();
        let px_vol = VolumeProfileColumnKind::Price.to_string();
        let qx_vol = VolumeProfileColumnKind::Quantity.to_string();

        df.lazy()
            .select([
                col(&px).apply(|x| Ok(Some(round(&x))), GetOutput::default()),
                col(&qx),
            ])
            .groupby([col(&px_vol)])
            .agg([col(&qx_vol).sum()])
            .sort(&px_vol, Default::default())
            .collect()
            .unwrap()
    }
}

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

    use polars::{df, prelude::NamedFrom};

    /// This unit test asserts, if:
    /// * the `volume_profile` of a DataFrame is computed correctly
    /// * the result is sorted in ascending order
    /// * the values for the price columns are rounded
    #[tokio::test]
    async fn test_volume_profile() {
        let agg_trades_volume = AggTradesVolume {};
        let df = df!(
            "px" => &[2.49, 1.0, 1.4, 2.5, 3.1],
            "qx" => &[2.0, 1.0, 1.0,  3.0, 3.0],
        )
        .unwrap();

        // The target DataFrame is sorted in ascending order and the values for the price columns are rounded
        let target = df!(
            "px" => &[1.0, 2.0, 3.0],
            "qx" => &[2.0, 2.0, 6.0],
        )
        .unwrap();

        let result = agg_trades_volume.vol_profile(df);
        assert_eq!(result.frame_equal(&target), true)
    }
}