fyers-rs 0.0.1

Idiomatic async Rust client for the Fyers API v3 broker 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
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

//! Market data REST API service.

use bytes::Bytes;

use crate::client::FyersClient;
use crate::error::Result;
use crate::models::market_data::{
    HistoryRequest, HistoryResponse, MarketDepthRequest, MarketDepthResponse, MarketStatusResponse,
    OptionChainRequest, OptionChainResponse, QuotesRequest, QuotesResponse,
    SymbolMasterExchangeSegment, SymbolMasterJson,
};
use crate::transport::{get_authenticated_base_json, get_authenticated_url_json, join_base_path};

/// Accessor for Fyers market data REST APIs.
#[derive(Debug, Clone, Copy)]
pub struct MarketDataService<'a> {
    client: &'a FyersClient,
}

impl<'a> MarketDataService<'a> {
    /// Create a new market data service accessor.
    pub(crate) const fn new(client: &'a FyersClient) -> Self {
        Self { client }
    }

    /// Access the underlying client.
    pub const fn client(&self) -> &'a FyersClient {
        self.client
    }

    pub async fn market_status(&self) -> Result<MarketStatusResponse> {
        get_authenticated_base_json(
            self.client.http(),
            self.client.config(),
            self.client.config().data_base_url(),
            "marketStatus",
        )
        .await
    }

    pub async fn history(&self, request: &HistoryRequest) -> Result<HistoryResponse> {
        let mut url = join_base_path(self.client.config().data_base_url(), "history");
        {
            let mut pairs = url.query_pairs_mut();
            pairs.append_pair("symbol", &request.symbol);
            pairs.append_pair("resolution", &request.resolution);
            pairs.append_pair("date_format", &request.date_format.to_string());
            pairs.append_pair("range_from", &request.range_from);
            pairs.append_pair("range_to", &request.range_to);
            if let Some(cont_flag) = request.cont_flag {
                pairs.append_pair("cont_flag", &cont_flag.to_string());
            }
            if let Some(oi_flag) = request.oi_flag {
                pairs.append_pair("oi_flag", &oi_flag.to_string());
            }
        }

        get_authenticated_url_json(self.client.http(), self.client.config(), url).await
    }

    pub async fn quotes(&self, request: &QuotesRequest) -> Result<QuotesResponse> {
        let mut url = join_base_path(self.client.config().data_base_url(), "quotes");
        url.query_pairs_mut()
            .append_pair("symbols", &request.symbols.join(","));

        get_authenticated_url_json(self.client.http(), self.client.config(), url).await
    }

    pub async fn depth(&self, request: &MarketDepthRequest) -> Result<MarketDepthResponse> {
        let mut url = join_base_path(self.client.config().data_base_url(), "depth");
        {
            let mut pairs = url.query_pairs_mut();
            pairs.append_pair("symbol", &request.symbol);
            pairs.append_pair("ohlcv_flag", &request.ohlcv_flag.to_string());
        }

        get_authenticated_url_json(self.client.http(), self.client.config(), url).await
    }

    pub async fn option_chain(&self, request: &OptionChainRequest) -> Result<OptionChainResponse> {
        let mut url = join_base_path(self.client.config().data_base_url(), "options-chain-v3");
        {
            let mut pairs = url.query_pairs_mut();
            pairs.append_pair("symbol", &request.symbol);
            if let Some(strikecount) = request.strikecount {
                pairs.append_pair("strikecount", &strikecount.to_string());
            }
            if let Some(timestamp) = &request.timestamp {
                pairs.append_pair("timestamp", timestamp);
            }
            if let Some(greeks) = &request.greeks {
                pairs.append_pair("greeks", greeks);
            }
        }

        get_authenticated_url_json(self.client.http(), self.client.config(), url).await
    }

    pub async fn symbol_master_csv(&self, segment: SymbolMasterExchangeSegment) -> Result<Bytes> {
        let url = join_base_path(
            self.client.config().symbols_base_url(),
            segment.csv_file_name(),
        );
        let response = self.client.http().get(url).send().await?;

        Ok(response.bytes().await?)
    }

    pub async fn symbol_master_json(
        &self,
        segment: SymbolMasterExchangeSegment,
    ) -> Result<SymbolMasterJson> {
        let url = join_base_path(
            self.client.config().symbols_base_url(),
            segment.json_file_name(),
        );
        let response = self.client.http().get(url).send().await?;

        Ok(response.json::<SymbolMasterJson>().await?)
    }
}