polygon 0.1.1

Rust client library for polygon.io
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
122
123
124
125
126
127
128

//! Main polygon.io API client
#[cfg(feature = "dotenvy")]
use crate::error::{Error, Result};
use crate::request::Request;

/// The main polygon.io API client.
///
/// When the `reqwest` feature is enabled, this uses `reqwest::Client` as the default HTTP client.
/// When the `reqwest` feature is disabled, you must provide your own HTTP client that implements [`Request`].
#[cfg(feature = "reqwest")]
pub struct Polygon<Client: Request = reqwest::Client> {
    client: Client,
    api_key: Option<String>,
}

/// The main polygon.io API client.
///
/// When the `reqwest` feature is enabled, this uses `reqwest::Client` as the default HTTP client.
/// When the `reqwest` feature is disabled, you must provide your own HTTP client that implements [`Request`].
#[cfg(not(feature = "reqwest"))]
pub struct Polygon<Client: Request> {
    client: Client,
    api_key: Option<String>,
}

// Implementation for any Client that implements Request
impl<Client: Request> Polygon<Client> {
    /// Create a new polygon.io client using the default HTTP client.
    ///
    /// This method is only available when the `dotenvy` feature is enabled.
    /// It loads the API key from the `POLYGON_API_KEY` environment variable using dotenvy.
    ///
    /// # Errors
    ///
    /// Returns an error if the environment variable cannot be loaded or if the API key is missing.
    #[cfg(feature = "dotenvy")]
    pub fn new() -> Result<Self> {
        dotenvy::dotenv().ok(); // Try to load .env file, ignore errors

        let api_key = std::env::var("POLYGON_API_KEY").map_err(|_| Error::MissingApiKey)?;

        Ok(Self {
            client: Client::new(),
            api_key: Some(api_key),
        })
    }
    /// Create a new polygon.io client with a custom HTTP client.
    ///
    /// This method is available regardless of which features are enabled.
    /// When the `dotenvy` feature is enabled, it will attempt to load the API key
    /// from the `POLYGON_API_KEY` environment variable.
    ///
    /// # Errors
    ///
    /// Returns an error if the `dotenvy` feature is enabled and the API key cannot be loaded.
    #[cfg(feature = "dotenvy")]
    pub fn with_client(client: Client) -> Result<Self> {
        dotenvy::dotenv().ok(); // Try to load .env file, ignore errors

        let api_key = std::env::var("POLYGON_API_KEY").map_err(|_| Error::MissingApiKey)?;

        Ok(Self {
            client,
            api_key: Some(api_key),
        })
    }

    /// Create a new polygon.io client with a custom HTTP client.
    ///
    /// This method is available when the `dotenvy` feature is disabled.
    /// You must manually set the API key using [`with_key`](Self::with_key).
    #[cfg(not(feature = "dotenvy"))]
    pub fn with_client(client: Client) -> Self {
        Self {
            client,
            api_key: None,
        }
    }

    /// Set the API key for this client.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use polygon::Polygon;
    ///
    /// let client = Polygon::default().with_key("my_api_key");
    /// ```
    pub fn with_key(mut self, api_key: impl Into<String>) -> Self {
        self.api_key = Some(api_key.into());
        self
    }

    /// Get the API key for this client.
    pub fn api_key(&self) -> Option<&str> {
        self.api_key.as_deref()
    }

    /// Get a reference to the underlying HTTP client.
    pub fn client(&self) -> &Client {
        &self.client
    }
}

// Default implementation
#[cfg(feature = "reqwest")]
impl Default for Polygon<reqwest::Client> {
    fn default() -> Self {
        Self {
            client: reqwest::Client::new(),
            api_key: None,
        }
    }
}

// Default implementation
#[cfg(not(feature = "reqwest"))]
impl<Client: Request> Default for Polygon<Client> {
    /// Create a default polygon.io client with no API key set.
    ///
    /// You must call [`with_key`](Self::with_key) to set the API key before making requests.
    fn default() -> Self {
        Self {
            client: Client::new(),
            api_key: None,
        }
    }
}