hko 1.13.0

Rust library for Hong Kong Observatory Open Data API
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

// Copyright (c) 2021 - 2025 GreenYun Organization
// SPDX-License-Identifier: MIT

//! Provides regional weather in Hong Kong - latest 10-minute mean visibility.
//! (the data provided is provisional)

use std::str::FromStr;

use chrono::{DateTime, FixedOffset, NaiveDateTime, TimeZone};
use chrono_tz::Hongkong;
use serde::Deserialize;

use crate::{
    common::{Lang, ValUnit},
    error::DataError,
    opendata::ResponseFormat,
};

#[derive(Clone, Debug)]
pub struct ResponseUnit {
    pub time: DateTime<FixedOffset>,
    pub station: String,
    pub visibility: ValUnit,
}

/// Main response type.
#[derive(Clone, Debug)]
pub struct Response(pub Vec<ResponseUnit>);

impl FromStr for Response {
    type Err = DataError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let raw = s.trim().as_bytes();

        Ok(Self(if raw.first().ok_or(DataError::EarlyEOF)? == &b'{' {
            // JSON
            #[derive(Deserialize)]
            struct JsonResponse {
                data: Vec<Vec<String>>,
            }

            let JsonResponse { data } = serde_json::from_str(s).map_err(|e| DataError::SourceFormat(e.to_string()))?;

            data.into_iter()
                .filter_map(|v| {
                    let time = NaiveDateTime::parse_from_str(v.first()?, "%Y%m%d%H%M").ok()?;
                    let time = Hongkong.from_local_datetime(&time).single()?.fixed_offset();

                    let station = v.get(1)?.clone();

                    let visibility = v.get(2)?;

                    let visibility = {
                        use nom::{error, number::complete};

                        let (unit, value) = complete::float::<_, error::Error<_>>(visibility.as_str()).ok()?;

                        ValUnit {
                            value,
                            unit: unit.trim().to_owned(),
                        }
                    };

                    Some(ResponseUnit {
                        time,
                        station,
                        visibility,
                    })
                })
                .collect()
        } else {
            // CSV
            #[derive(Deserialize)]
            struct CsvResponse {
                time: String,
                station: String,
                visibility: String,
            }

            let mut rdr = csv::ReaderBuilder::new().has_headers(false).from_reader(s.as_bytes());

            rdr.records()
                .filter_map(|r| {
                    let CsvResponse {
                        time,
                        station,
                        visibility,
                    } = r.ok()?.deserialize(None).ok()?;

                    let time = NaiveDateTime::parse_from_str(time.as_str(), "%Y%m%d%H%M").ok()?;
                    let time = Hongkong.from_local_datetime(&time).single()?.fixed_offset();

                    let visibility = {
                        use nom::{error, number::complete};

                        let (unit, value) = complete::float::<_, error::Error<_>>(visibility.as_str()).ok()?;

                        ValUnit {
                            value,
                            unit: unit.trim().to_owned(),
                        }
                    };

                    Some(ResponseUnit {
                        time,
                        station,
                        visibility,
                    })
                })
                .collect()
        }))
    }
}

#[must_use]
pub fn url(lang: &Lang, response_format: Option<ResponseFormat>) -> String {
    format!(
        concat_url!(LTMV, "&lang={}{}"),
        lang,
        response_format.map(|f| format!("&rformat={f}")).unwrap_or_default(),
    )
}

#[allow(clippy::missing_errors_doc)]
#[cfg(feature = "fetch")]
#[cfg_attr(docsrs, doc(cfg(feature = "fetch")))]
pub async fn fetch(lang: Lang, response_format: Option<ResponseFormat>) -> anyhow::Result<Response> {
    let client = reqwest::Client::builder().build()?;

    fetch_with_client(lang, response_format, client).await
}

#[allow(clippy::missing_errors_doc)]
#[cfg(feature = "fetch")]
#[cfg_attr(docsrs, doc(cfg(feature = "fetch")))]
pub async fn fetch_with_client(
    lang: Lang,
    response_format: Option<ResponseFormat>,
    client: reqwest::Client,
) -> anyhow::Result<Response> {
    let resp = client.get(url(&lang, response_format)).send().await?.text().await?;

    Ok(Response::from_str(&resp)?)
}