ibapi 3.0.1

A Rust implementation of the Interactive Brokers TWS API, providing a reliable and user friendly interface for TWS and IB Gateway. Designed with a focus on simplicity and performance.
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

use time::OffsetDateTime;

use crate::contracts::Contract;
use crate::market_data::historical::{Duration, Schedule};
use crate::Error;

#[cfg(test)]
#[path = "schedule_tests.rs"]
mod tests;

/// Builder for the historical-schedule API.
#[must_use = "HistoricalScheduleBuilder does nothing until you call .fetch()"]
pub struct HistoricalScheduleBuilder<'a, C> {
    client: &'a C,
    contract: &'a Contract,
    duration: Duration,
    ending: Option<OffsetDateTime>,
}

impl<'a, C> HistoricalScheduleBuilder<'a, C> {
    pub(crate) fn new(client: &'a C, contract: &'a Contract, duration: Duration) -> Self {
        Self {
            client,
            contract,
            duration,
            ending: None,
        }
    }

    /// Anchor the schedule to a specific end date (defaults to now).
    pub fn ending(mut self, end_date: OffsetDateTime) -> Self {
        self.ending = Some(end_date);
        self
    }
}

#[cfg(feature = "sync")]
impl<'a> HistoricalScheduleBuilder<'a, crate::client::sync::Client> {
    /// Submit the request and return the [`Schedule`].
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use ibapi::client::blocking::Client;
    /// use ibapi::contracts::Contract;
    /// use ibapi::market_data::historical::ToDuration;
    /// use time::macros::datetime;
    ///
    /// let client = Client::connect("127.0.0.1:4002", 100).expect("connection failed");
    /// let contract = Contract::stock("GM").build();
    ///
    /// // Ending at a specific date:
    /// let schedule = client
    ///     .historical_schedules(&contract, 30.days())
    ///     .ending(datetime!(2023-04-15 0:00 UTC))
    ///     .fetch()
    ///     .expect("historical schedule request failed");
    ///
    /// // Ending now (no `.ending()`):
    /// let schedule = client
    ///     .historical_schedules(&contract, 30.days())
    ///     .fetch()
    ///     .expect("historical schedule request failed");
    ///
    /// for session in &schedule.sessions {
    ///     println!("{session:?}");
    /// }
    /// ```
    pub fn fetch(self) -> Result<Schedule, Error> {
        crate::market_data::historical::sync::historical_schedule(self.client, self.contract, self.ending, self.duration)
    }
}

#[cfg(feature = "async")]
impl<'a> HistoricalScheduleBuilder<'a, crate::client::r#async::Client> {
    /// Submit the request and return the [`Schedule`].
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use ibapi::prelude::*;
    /// use time::macros::datetime;
    ///
    /// #[tokio::main]
    /// async fn main() {
    ///     let client = Client::connect("127.0.0.1:4002", 100).await.expect("connection failed");
    ///     let contract = Contract::stock("GM").build();
    ///
    ///     // Ending at a specific date:
    ///     let schedule = client
    ///         .historical_schedules(&contract, 30.days())
    ///         .ending(datetime!(2023-04-15 0:00 UTC))
    ///         .fetch()
    ///         .await
    ///         .expect("historical schedule request failed");
    ///
    ///     for session in &schedule.sessions {
    ///         println!("{session:?}");
    ///     }
    /// }
    /// ```
    pub async fn fetch(self) -> Result<Schedule, Error> {
        crate::market_data::historical::r#async::historical_schedule(self.client, self.contract, self.ending, self.duration).await
    }
}