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
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

use std::collections::HashMap;

use polars::prelude::{DataFrame, IntoLazy, LazyFrame};
use serde::{Deserialize, Serialize};

use crate::{
    converter::pnl_to_report::{as_equity_curve, PnLToReportRequestBuilder},
    data_frame_operations::io_operations::save_df_as_csv,
    equity_curve::EquityCurvesAggMarkets,
    lazy_frame_operations::trait_extensions::{MyLazyFrameVecOperations, MyLazyFrameOperations},
    performance_report::PerformanceReportAggMarkets,
    trade_breakdown_report::TradeBreakDownReportAggMarkets,
    MarketKind,
};

use super::pnl_statement::PnLStatement;

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PnLStatementAggMarkets {
    pub strategy_name: String,
    pub markets: Vec<MarketKind>,
    pub years: Vec<u32>,
    pub pnl_data: HashMap<u32, DataFrame>,
}

impl PnLStatementAggMarkets {
    pub fn save_as_csv(&self, file_name: &str) {
        self.pnl_data.iter().for_each(|(year, pnl)| {
            save_df_as_csv(
                &mut pnl.clone(),
                &format!("{file_name}_all_markets_{year}_pnl"),
            )
        })
    }

    pub fn agg_year(&self) -> DataFrame {
        let ldfs = self.years.iter().fold(Vec::new(), |mut acc, year| {
            acc.push(self.pnl_data.get(year).unwrap().clone().lazy());
            acc
        });
        ldfs.concatenate_to_lazy_frame()
            .sort_by_date()
            .collect()
            .unwrap()
    }

    pub fn compute_trade_breakdown_report(&self) -> TradeBreakDownReportAggMarkets {
        let request_builder = PnLToReportRequestBuilder::new()
            .is_agg_markets(true)
            .is_agg_years(false);
        let trade_breakdown_reports = self
            .pnl_data
            .iter()
            .map(|(year, pnl_report)| {
                request_builder
                    .clone()
                    .with_pnl(pnl_report.clone())
                    .with_strategy(self.strategy_name.clone())
                    .with_year(*year)
                    .build()
                    .as_trade_breakdown_df()
            })
            .map(|df| df.lazy())
            .collect::<Vec<LazyFrame>>()
            .concatenate_to_data_frame()
            .with_row_count("#", Some(1))
            .unwrap();

        TradeBreakDownReportAggMarkets {
            markets: self.markets.clone(),
            report: trade_breakdown_reports,
        }
    }
    pub fn compute_performance_report(&self) -> PerformanceReportAggMarkets {
        let request_builder = PnLToReportRequestBuilder::new()
            .is_agg_markets(true)
            .is_agg_years(false);
        let trade_breakdown_reports = self
            .pnl_data
            .iter()
            .map(|(year, pnl_report)| {
                request_builder
                    .clone()
                    .with_pnl(pnl_report.clone())
                    .with_strategy(self.strategy_name.clone())
                    .with_year(*year)
                    .build()
                    .as_performance_report_df()
            })
            .map(|df| df.lazy())
            .collect::<Vec<LazyFrame>>()
            .concatenate_to_data_frame()
            .with_row_count("#", Some(1))
            .unwrap();

        PerformanceReportAggMarkets {
            markets: self.markets.clone(),
            report: trade_breakdown_reports,
        }
    }

    pub fn compute_equity_curves(&self) -> EquityCurvesAggMarkets {
        let equity_curves = self
            .pnl_data
            .iter()
            .map(|(year, pnl_report)| (*year, as_equity_curve(&pnl_report, false)))
            .collect();

        EquityCurvesAggMarkets {
            markets: self.markets.clone(),
            years: self.years.clone(),
            curves: equity_curves,
        }
    }
}

impl From<PnLStatement> for PnLStatementAggMarkets {
    fn from(value: PnLStatement) -> Self {
        Self {
            strategy_name: value.strategy_name.clone(),
            markets: value.markets.clone(),
            years: value.get_years(),
            pnl_data: value.agg_markets(),
        }
    }
}