finance-query 3.0.0

// @generated by `cargo soothfast docs gen-tests`
// source: docs/library/forex.md
#![allow(unused)]

// line 27: compile-only (no_run)
#[cfg(feature = "alphavantage")]
#[rustfmt::skip]
#[allow(dead_code)]
fn doc_block_line_27() {
    use finance_query::{Capability, Provider, Providers};

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn std::error::Error>> {
        let providers = Providers::builder()
            .route(Capability::FOREX, [Provider::AlphaVantage])
            .build()
            .await?;

        let pair = providers.forex("EUR", "USD");
        Ok(())
    }
}

// line 46: compile-only (no_run)
#[cfg(feature = "alphavantage")]
#[rustfmt::skip]
#[allow(dead_code)]
fn doc_block_line_46() {
    use finance_query::{Capability, Provider, Providers};

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn std::error::Error>> {
        let providers = Providers::builder()
            .route(Capability::FOREX, [Provider::AlphaVantage])
            .build()
            .await?;
        let pair = providers.forex("EUR", "USD");

        let quote = pair.quote().await?;

        println!("Symbol: {}", quote.symbol);
        if let Some(price) = quote.price {
            println!("Rate: {:.6}", price);
        }
        if let Some(bid) = quote.bid {
            println!("Bid:  {:.6}", bid);
        }
        if let Some(ask) = quote.ask {
            println!("Ask:  {:.6}", ask);
        }
        if let (Some(chg), Some(pct)) = (quote.change, quote.change_percent) {
            println!("Change: {:+.6} ({:+.4}%)", chg, pct);
        }
        Ok(())
    }
}

// line 143: compile-only (no_run)
#[cfg(feature = "alphavantage")]
#[rustfmt::skip]
#[allow(dead_code)]
fn doc_block_line_143() {
    use finance_query::{Capability, Interval, Provider, Providers, TimeRange};

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn std::error::Error>> {
        let providers = Providers::builder()
            .route(Capability::FOREX, [Provider::AlphaVantage])
            .build()
            .await?;
        let pair = providers.forex("EUR", "USD");

        let chart = pair.chart(Interval::OneDay, TimeRange::OneMonth).await?;

        println!("Pair: {}", chart.symbol);
        assert!(!chart.candles.is_empty());

        for candle in &chart.candles {
            println!(
                "{}: O={:.6}, H={:.6}, L={:.6}, C={:.6}",
                candle.timestamp, candle.open, candle.high, candle.low, candle.close
            );
        }
        Ok(())
    }
}

// line 177: compile-only (no_run)
#[cfg(feature = "alphavantage")]
#[rustfmt::skip]
#[allow(dead_code)]
fn doc_block_line_177() {
    use finance_query::{Capability, Provider, Providers, TimeRange};

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn std::error::Error>> {
        let providers = Providers::builder()
            .route(Capability::FOREX, [Provider::AlphaVantage])
            .build()
            .await?;
        let pair = providers.forex("EUR", "USD");

        let history = pair.history(TimeRange::OneMonth).await?;

        assert!(!history.candles.is_empty());

        if let Some(last) = history.candles.last() {
            println!("Most recent close: {:.6}", last.close);
        }
        Ok(())
    }
}

// line 210: compile-only (no_run)
#[cfg(all(feature = "risk", feature = "alphavantage"))]
#[rustfmt::skip]
#[allow(dead_code)]
fn doc_block_line_210() {
    use finance_query::indicators::Indicator;
    use finance_query::{Capability, Interval, Provider, Providers, TimeRange};

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn std::error::Error>> {
        let providers = Providers::builder()
            .route(Capability::FOREX, [Provider::AlphaVantage])
            .build()
            .await?;
        let pair = providers.forex("EUR", "USD");

        let summary = pair
            .indicators(Interval::OneDay, TimeRange::ThreeMonths)
            .await?;
        if let Some(rsi) = summary.rsi_14 {
            println!("RSI(14): {:.2}", rsi);
        }

        let rsi_21 = pair
            .indicator(Indicator::Rsi(21), Interval::OneDay, TimeRange::ThreeMonths)
            .await?;

        let risk = pair.risk(Interval::OneDay, TimeRange::OneYear).await?;
        println!("VaR 95%:      {:.2}%", risk.var_95 * 100.0);
        println!("Max Drawdown: {:.2}%", risk.max_drawdown * 100.0);
        Ok(())
    }
}

// line 250: compile-only (no_run)
#[cfg(feature = "alphavantage")]
#[rustfmt::skip]
#[allow(dead_code)]
fn doc_block_line_250() {
    use finance_query::{Capability, Provider, Providers};
    use std::time::Duration;

    #[tokio::main]
    async fn main() -> Result<(), Box<dyn std::error::Error>> {
        let providers = Providers::builder()
            .route(Capability::FOREX, [Provider::AlphaVantage])
            .build()
            .await?;

        // Default: the first call hits the network, every later call is served
        // from cache for as long as this handle is alive.
        let pair = providers.forex("EUR", "USD");
        let _q1 = pair.quote().await?;
        let _q2 = pair.quote().await?; // served from cache

        // Bound reuse to a 60-second TTL instead.
        let pair = providers
            .forex("EUR", "USD")
            .cache(Duration::from_secs(60));

        // Or opt out entirely — every call fetches fresh.
        let pair = providers.forex("EUR", "USD").no_cache();
        let _fresh = pair.quote().await?;
        Ok(())
    }
}