gflights 0.2.1

Unofficial async Rust client for the Google Flights web API — search flights, price graphs, and booking offers.
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
146
147
148
149
150
151
152
153
154

use anyhow::Result;
use chrono::{Months, NaiveDate};
use clap::Parser;
use gflights::parsers::common::{TravelClass, Travelers};
use gflights::requests::api::ApiClient;
use gflights::requests::config::{Config, Currency};

use super::OutputFormat;

/// Arguments for the `cheap` subcommand.
#[derive(Parser, Debug)]
pub struct CheapArgs {
    /// Departure airport IATA code or city name (e.g. LUX, "London").
    #[arg(long)]
    pub from: String,

    /// Destination airport IATA code or city name (e.g. JFK, "New York").
    #[arg(long)]
    pub to: String,

    /// Start of the search window (YYYY-MM-DD).
    #[arg(long)]
    pub date: NaiveDate,

    /// Number of months to scan from --date. [default: 3]
    #[arg(long, default_value = "3")]
    pub months: u32,

    /// Fixed round-trip duration in days (e.g. 7). Omit for one-way results.
    #[arg(long)]
    pub trip_days: Option<u32>,

    /// Number of adult passengers.
    #[arg(long, default_value = "1")]
    pub adults: u32,

    /// Travel class.
    #[arg(long, default_value = "economy")]
    pub class: TravelClass,

    /// Currency for prices.
    #[arg(long, default_value = "euro")]
    pub currency: Currency,

    /// BCP-47 language subtag (e.g. en, fr, de).
    #[arg(long, default_value = "en")]
    pub lang: String,

    /// ISO 3166-1 alpha-2 country code (e.g. GB, FR, US).
    #[arg(long, default_value = "GB")]
    pub country: String,

    /// Output format.
    #[arg(long, default_value = "table")]
    pub format: OutputFormat,
}

pub async fn cmd_cheap(args: CheapArgs, client: &ApiClient) -> Result<()> {
    let travelers = Travelers::new(vec![args.adults as i32, 0, 0, 0])?;
    let config = Config::builder()
        .departure(&args.from, client)
        .await?
        .destination(&args.to, client)
        .await?
        .departing_date(args.date)
        .travelers(travelers)
        .travel_class(args.class)
        .currency(args.currency)
        .language(args.lang)
        .country(args.country)
        .build()?;

    let results = client
        .cheapest_dates(&config, Months::new(args.months), args.trip_days)
        .await?;

    if results.is_empty() {
        eprintln!("No dates found.");
        return Ok(());
    }

    match args.format {
        OutputFormat::Json => {
            println!("{}", serde_json::to_string_pretty(&results)?);
        }
        OutputFormat::Table => {
            let is_roundtrip = args.trip_days.is_some();
            if is_roundtrip {
                println!("{:<12}  {:<12}  {:>6}", "DEP DATE", "RET DATE", "PRICE");
            } else {
                println!("{:<12}  {:>6}", "DEP DATE", "PRICE");
            }
            println!("{}", "-".repeat(if is_roundtrip { 34 } else { 20 }));
            for r in &results {
                if let Some(ret) = r.return_date {
                    println!("{:<12}  {:<12}  {:>6}", r.departure_date, ret, r.price);
                } else {
                    println!("{:<12}  {:>6}", r.departure_date, r.price);
                }
            }
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn cheap_args_parse_one_way() {
        let args = CheapArgs::try_parse_from([
            "cheap",
            "--from",
            "LUX",
            "--to",
            "JFK",
            "--date",
            "2026-09-01",
        ])
        .unwrap();
        assert_eq!(args.from, "LUX");
        assert_eq!(args.to, "JFK");
        assert!(args.trip_days.is_none());
        assert_eq!(args.months, 3);
    }

    #[test]
    fn cheap_args_parse_round_trip() {
        let args = CheapArgs::try_parse_from([
            "cheap",
            "--from",
            "LUX",
            "--to",
            "JFK",
            "--date",
            "2026-09-01",
            "--trip-days",
            "7",
            "--months",
            "6",
        ])
        .unwrap();
        assert_eq!(args.trip_days, Some(7));
        assert_eq!(args.months, 6);
    }

    #[test]
    fn cheap_args_requires_from() {
        assert!(
            CheapArgs::try_parse_from(["cheap", "--to", "JFK", "--date", "2026-09-01"]).is_err()
        );
    }
}