yfinance-rs 0.9.1

Ergonomic Rust client for Yahoo Finance, supporting historical prices, real-time streaming, options, fundamentals, and more.
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

use super::{CurrencyPurpose, ResolvedCurrency, ResolvedCurrencyUnit};
use crate::core::{ProjectionContext, ProjectionIssue, YfError};

#[derive(Debug)]
pub struct ProjectedCurrency {
    unit: Option<ResolvedCurrencyUnit>,
    issue: Option<ProjectionIssue>,
}

impl ProjectedCurrency {
    const fn resolved(unit: ResolvedCurrencyUnit) -> Self {
        Self {
            unit: Some(unit),
            issue: None,
        }
    }

    const fn omitted(issue: ProjectionIssue) -> Self {
        Self {
            unit: None,
            issue: Some(issue),
        }
    }

    pub fn into_unit(self) -> Option<ResolvedCurrencyUnit> {
        self.unit
    }

    pub const fn issue(&self) -> Option<&ProjectionIssue> {
        self.issue.as_ref()
    }
}

pub fn project_currency_resolution(
    ctx: &mut ProjectionContext,
    symbol: &str,
    purpose: CurrencyPurpose,
    direct_code: Option<&str>,
    resolution: Result<ResolvedCurrency, YfError>,
) -> Result<ProjectedCurrency, YfError> {
    match resolution {
        Ok(resolved) => {
            for invalid in resolved.invalid_evidence() {
                ctx.omitted_present_field(
                    invalid.path(),
                    Some(symbol),
                    ProjectionIssue::InvalidCurrency {
                        code: invalid.code().to_string(),
                    },
                )?;
            }
            ctx.currency_resolution(symbol, purpose, &resolved)?;
            Ok(ProjectedCurrency::resolved(resolved.into_unit()))
        }
        Err(err) => Ok(ProjectedCurrency::omitted(currency_resolution_issue(
            direct_code,
            &err,
        ))),
    }
}

fn invalid_direct_currency_issue(code: Option<&str>) -> Option<ProjectionIssue> {
    let code = code.map(str::trim).filter(|code| !code.is_empty())?;

    ResolvedCurrencyUnit::from_code(code)
        .is_none()
        .then(|| ProjectionIssue::InvalidCurrency {
            code: code.to_string(),
        })
}

fn currency_resolution_issue(direct_code: Option<&str>, err: &YfError) -> ProjectionIssue {
    if let Some(issue) = invalid_direct_currency_issue(direct_code) {
        return issue;
    }
    if let Some(issue) = invalid_resolved_currency_issue(err) {
        return issue;
    }

    match err {
        YfError::MissingData(_) => ProjectionIssue::CurrencyUnresolved,
        other => ProjectionIssue::ProviderError {
            message: other.to_string(),
        },
    }
}

fn invalid_resolved_currency_issue(err: &YfError) -> Option<ProjectionIssue> {
    let YfError::InvalidData(message) = err else {
        return None;
    };
    if !message.contains(" currency code ") {
        return None;
    }

    let (_, code) = message.rsplit_once(": ")?;
    Some(ProjectionIssue::InvalidCurrency {
        code: code.to_string(),
    })
}