alpaca_data/crypto/
client.rs

1use std::sync::Arc;
2
3use crate::{
4    Error,
5    client::Inner,
6    common::response::ResponseStream,
7    transport::endpoint::Endpoint,
8    transport::pagination::{collect_all, stream_pages},
9};
10
11use super::{
12    BarsRequest, BarsResponse, LatestBarsRequest, LatestBarsResponse, LatestOrderbooksRequest,
13    LatestOrderbooksResponse, LatestQuotesRequest, LatestQuotesResponse, LatestTradesRequest,
14    LatestTradesResponse, QuotesRequest, QuotesResponse, SnapshotsRequest, SnapshotsResponse,
15    TradesRequest, TradesResponse,
16};
17
18#[derive(Clone, Debug)]
19pub struct CryptoClient {
20    inner: Arc<Inner>,
21}
22
23impl CryptoClient {
24    pub(crate) fn new(inner: Arc<Inner>) -> Self {
25        Self { inner }
26    }
27
28    pub async fn bars(&self, request: BarsRequest) -> Result<BarsResponse, Error> {
29        request.validate()?;
30        let endpoint = Endpoint::crypto_bars(request.loc.unwrap_or_default());
31        self.inner
32            .http
33            .get_json(
34                &self.inner.base_url,
35                endpoint,
36                &self.inner.auth,
37                request.to_query(),
38            )
39            .await
40    }
41
42    pub async fn bars_all(&self, request: BarsRequest) -> Result<BarsResponse, Error> {
43        let client = self.clone();
44
45        collect_all(request, move |request| {
46            let client = client.clone();
47            async move { client.bars(request).await }
48        })
49        .await
50    }
51
52    pub fn bars_stream(&self, request: BarsRequest) -> ResponseStream<Result<BarsResponse, Error>> {
53        let client = self.clone();
54        stream_pages(request, move |request| {
55            let client = client.clone();
56            async move { client.bars(request).await }
57        })
58    }
59
60    pub async fn quotes(&self, request: QuotesRequest) -> Result<QuotesResponse, Error> {
61        request.validate()?;
62        let endpoint = Endpoint::crypto_quotes(request.loc.unwrap_or_default());
63        self.inner
64            .http
65            .get_json(
66                &self.inner.base_url,
67                endpoint,
68                &self.inner.auth,
69                request.to_query(),
70            )
71            .await
72    }
73
74    pub async fn quotes_all(&self, request: QuotesRequest) -> Result<QuotesResponse, Error> {
75        let client = self.clone();
76
77        collect_all(request, move |request| {
78            let client = client.clone();
79            async move { client.quotes(request).await }
80        })
81        .await
82    }
83
84    pub fn quotes_stream(
85        &self,
86        request: QuotesRequest,
87    ) -> ResponseStream<Result<QuotesResponse, Error>> {
88        let client = self.clone();
89        stream_pages(request, move |request| {
90            let client = client.clone();
91            async move { client.quotes(request).await }
92        })
93    }
94
95    pub async fn trades(&self, request: TradesRequest) -> Result<TradesResponse, Error> {
96        request.validate()?;
97        let endpoint = Endpoint::crypto_trades(request.loc.unwrap_or_default());
98        self.inner
99            .http
100            .get_json(
101                &self.inner.base_url,
102                endpoint,
103                &self.inner.auth,
104                request.to_query(),
105            )
106            .await
107    }
108
109    pub async fn trades_all(&self, request: TradesRequest) -> Result<TradesResponse, Error> {
110        let client = self.clone();
111
112        collect_all(request, move |request| {
113            let client = client.clone();
114            async move { client.trades(request).await }
115        })
116        .await
117    }
118
119    pub fn trades_stream(
120        &self,
121        request: TradesRequest,
122    ) -> ResponseStream<Result<TradesResponse, Error>> {
123        let client = self.clone();
124        stream_pages(request, move |request| {
125            let client = client.clone();
126            async move { client.trades(request).await }
127        })
128    }
129
130    pub async fn latest_bars(
131        &self,
132        request: LatestBarsRequest,
133    ) -> Result<LatestBarsResponse, Error> {
134        request.validate()?;
135        let endpoint = Endpoint::crypto_latest_bars(request.loc.unwrap_or_default());
136        self.inner
137            .http
138            .get_json(
139                &self.inner.base_url,
140                endpoint,
141                &self.inner.auth,
142                request.to_query(),
143            )
144            .await
145    }
146
147    pub async fn latest_quotes(
148        &self,
149        request: LatestQuotesRequest,
150    ) -> Result<LatestQuotesResponse, Error> {
151        request.validate()?;
152        let endpoint = Endpoint::crypto_latest_quotes(request.loc.unwrap_or_default());
153
154        self.inner
155            .http
156            .get_json(
157                &self.inner.base_url,
158                endpoint,
159                &self.inner.auth,
160                request.to_query(),
161            )
162            .await
163    }
164
165    pub async fn latest_trades(
166        &self,
167        request: LatestTradesRequest,
168    ) -> Result<LatestTradesResponse, Error> {
169        request.validate()?;
170        let endpoint = Endpoint::crypto_latest_trades(request.loc.unwrap_or_default());
171        self.inner
172            .http
173            .get_json(
174                &self.inner.base_url,
175                endpoint,
176                &self.inner.auth,
177                request.to_query(),
178            )
179            .await
180    }
181
182    pub async fn latest_orderbooks(
183        &self,
184        request: LatestOrderbooksRequest,
185    ) -> Result<LatestOrderbooksResponse, Error> {
186        request.validate()?;
187        let endpoint = Endpoint::crypto_latest_orderbooks(request.loc.unwrap_or_default());
188        self.inner
189            .http
190            .get_json(
191                &self.inner.base_url,
192                endpoint,
193                &self.inner.auth,
194                request.to_query(),
195            )
196            .await
197    }
198
199    pub async fn snapshots(&self, request: SnapshotsRequest) -> Result<SnapshotsResponse, Error> {
200        request.validate()?;
201        let endpoint = Endpoint::crypto_snapshots(request.loc.unwrap_or_default());
202        self.inner
203            .http
204            .get_json(
205                &self.inner.base_url,
206                endpoint,
207                &self.inner.auth,
208                request.to_query(),
209            )
210            .await
211    }
212}
alpaca_data/crypto/client.rs

alpaca_data/crypto/
client.rs
