trading-ig 0.1.0

Async Rust client for the IG Markets REST and Lightstreamer streaming APIs
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

//! Client sentiment API endpoints.

use http::Method;
use serde::Deserialize;
use tracing::instrument;

use crate::Result;
use crate::client::IgClient;

use super::models::Sentiment;

/// Typed accessor for the `/clientsentiment` endpoints.
///
/// Obtain via [`IgClient::client_sentiment`].
#[derive(Debug)]
pub struct ClientSentimentApi<'a> {
    pub(crate) client: &'a IgClient,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct SentimentEnvelope {
    client_sentiments: Vec<Sentiment>,
}

impl ClientSentimentApi<'_> {
    /// Fetch client sentiment for a single market.
    ///
    /// # Errors
    ///
    /// Returns [`crate::Error::Api`] with `errorCode`
    /// `error.public-api.failure.market-not-found` if the market ID does not
    /// exist.
    #[instrument(skip(self), fields(market_id = %market_id))]
    pub async fn get(&self, market_id: &str) -> Result<Sentiment> {
        let path = format!("clientsentiment/{market_id}");
        self.client
            .transport
            .request::<(), Sentiment>(
                Method::GET,
                &path,
                Some(1),
                None::<&()>,
                &self.client.session,
            )
            .await
    }

    /// Fetch client sentiment for multiple markets in a single call.
    ///
    /// `market_ids` should be a slice of market identifiers (e.g.
    /// `["CC.D.LCO.UNC.IP", "IX.D.DAX.IFD.IP"]`).
    #[instrument(skip(self), fields(count = market_ids.len()))]
    pub async fn get_many(&self, market_ids: &[&str]) -> Result<Vec<Sentiment>> {
        let ids = market_ids.join(",");
        let path = format!("clientsentiment?marketIds={ids}");
        let envelope: SentimentEnvelope = self
            .client
            .transport
            .request(
                Method::GET,
                &path,
                Some(1),
                None::<&()>,
                &self.client.session,
            )
            .await?;
        Ok(envelope.client_sentiments)
    }

    /// Fetch client sentiment for markets related to the given market.
    ///
    /// Returns sentiment for correlated instruments that IG considers
    /// "related" to `market_id`.
    #[instrument(skip(self), fields(market_id = %market_id))]
    pub async fn related(&self, market_id: &str) -> Result<Vec<Sentiment>> {
        let path = format!("clientsentiment/related/{market_id}");
        let envelope: SentimentEnvelope = self
            .client
            .transport
            .request(
                Method::GET,
                &path,
                Some(1),
                None::<&()>,
                &self.client.session,
            )
            .await?;
        Ok(envelope.client_sentiments)
    }
}