stockholm 0.2.36

A laboratory for algorithmic trading.
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

mod backtest;
mod historical;
mod infer;
mod run;
// Keep the full persistence API compiled while state mutation and saving are not yet implemented.
#[allow(dead_code)]
mod state;
mod train;

#[macro_use]
extern crate log;

use chrono::Local;
use clap::{ArgAction, Parser, Subcommand as ClapSubcommand};
use env_logger::{Builder, fmt::style::Effects};
use log::LevelFilter;
use std::{env, error::Error, io::Write, str::FromStr};

// This symbol is used when the user does not select an instrument.
const DEFAULT_SYMBOL: &str = "SOXL";
const DEFAULT_LOG_LEVEL: LevelFilter = LevelFilter::Debug;

// Set up timestamped, leveled logging for operational output.
fn set_up_logging() {
    Builder::new()
        .filter_module(
            module_path!(),
            LevelFilter::from_str(
                &env::var("LOG_LEVEL").unwrap_or_else(|_| DEFAULT_LOG_LEVEL.to_string()),
            )
            .unwrap_or(DEFAULT_LOG_LEVEL),
        )
        .format(|buf, record| {
            let style = buf
                .default_level_style(record.level())
                .effects(Effects::BOLD);

            writeln!(
                buf,
                "{style}[{} {}]{style:#} {}",
                Local::now().format("%Y-%m-%d %H:%M:%S %:z"),
                record.level(),
                record.args(),
            )
        })
        .init();
}

// This struct represents the command-line arguments.
#[derive(Parser)]
#[command(
    about = concat!(
        env!("CARGO_PKG_DESCRIPTION"),
        "\n\n",
        "More information can be found at: ",
        env!("CARGO_PKG_HOMEPAGE"),
    ),
    version,
    disable_version_flag = true
)]
struct Cli {
    #[arg(short, long, help = "Print version", action = ArgAction::Version)]
    _version: Option<bool>,

    /// Address of the running TWS or IB Gateway API.
    #[arg(long, default_value = "127.0.0.1:4001")]
    address: String,

    /// Client ID to use for the API connection.
    #[arg(long, default_value_t = 100)]
    client_id: i32,

    #[command(subcommand)]
    command: Option<Subcommand>,
}

// These subcommands select the program's operating mode.
#[derive(ClapSubcommand)]
enum Subcommand {
    #[command(about = "Backtest a trading strategy")]
    Backtest(backtest::Args),

    #[command(about = "Run the trading bot (default)")]
    Run(run::Args),

    #[command(about = "Fetch historical market data as CSV")]
    Historical(historical::Args),

    #[command(about = "Run one inference with a trained neural network")]
    Infer(infer::Args),

    #[command(about = "Train a neural network on historical stock data")]
    Train(train::Args),
}

// Parse the configuration and run the selected operating mode.
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Set up logging before performing any fallible application work.
    set_up_logging();

    // Parse the command-line arguments.
    let cli = Cli::parse();

    // Decide what to do based on the subcommand.
    match cli.command {
        Some(Subcommand::Backtest(args)) => backtest::run(&args),
        Some(Subcommand::Run(args)) => run::run(&cli.address, cli.client_id, &args).await,
        Some(Subcommand::Historical(args)) => {
            historical::run(&cli.address, cli.client_id, &args).await
        }
        Some(Subcommand::Infer(args)) => infer::run(&args),
        Some(Subcommand::Train(args)) => train::run(&args),
        None => run::run(&cli.address, cli.client_id, &run::Args::default()).await,
    }
}

#[cfg(test)]
mod tests {
    use super::Cli;
    use clap::CommandFactory;

    #[test]
    fn verify_cli() {
        Cli::command().debug_assert();
    }
}