flights 0.3.0__py3-none-any.whl

fli/app/__init__.py

@@ -0,0 +1,5 @@
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+load_dotenv(Path(__file__).parents[1].joinpath(".env"))

fli/app/main.py

@@ -0,0 +1,197 @@
+from datetime import datetime, timedelta
+
+import pandas as pd
+import streamlit as st
+
+from fli.app.utils import format_enum
+from fli.models import (
+    Airport,
+    DateSearchFilters,
+    FlightSegment,
+    MaxStops,
+    PassengerInfo,
+    SeatType,
+    SortBy,
+)
+from fli.search.dates import SearchDates
+from fli.search.flights import SearchFlights, SearchFlightsFilters
+
+# Set page config
+st.set_page_config(page_title="Fli", page_icon=":airplane:", layout="wide")
+
+# Add title and description
+st.title("✈️ Fli")
+st.markdown("""
+Search for flights using Google Flights data. 
+Enter your travel details below to find available flights.
+""")
+
+# Create first row of inputs
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    # Origin airport
+    departure_airport = st.selectbox(
+        "From",
+        options=list(Airport),
+        format_func=lambda x: f"{x.name} ({x.value})",
+        index=list(Airport).index(Airport.SFO),
+    )
+
+with col2:
+    # Destination airport
+    arrival_airport = st.selectbox(
+        "To",
+        options=list(Airport),
+        format_func=lambda x: f"{x.name} ({x.value})",
+        index=list(Airport).index(Airport.JFK),
+    )
+
+with col3:
+    # Departure date
+    min_date = datetime.now().date()
+    max_date = min_date + timedelta(days=365)
+    default_date = min_date + timedelta(days=30)
+    departure_date = st.date_input(
+        "Departure Date", min_value=min_date, max_value=max_date, value=default_date
+    )
+
+# Create second row of inputs
+col4, col5, col6 = st.columns(3)
+
+with col4:
+    # Maximum stops
+    stops = st.selectbox("Maximum Stops", options=list(MaxStops), format_func=format_enum)
+
+with col5:
+    # Seat type
+    seat_type = st.selectbox("Cabin Class", options=list(SeatType), format_func=format_enum)
+
+with col6:
+    # Number of passengers
+    num_adults = st.number_input("Number of Adults", min_value=1, max_value=9, value=1)
+
+# Sort criteria
+sort_by = st.selectbox("Sort Results By", options=list(SortBy), format_func=format_enum)
+
+# Search button
+if st.button("Search Flights", type="primary"):
+    # Input validation
+    if departure_airport == arrival_airport:
+        st.error("Origin and destination airports cannot be the same.")
+    else:
+        try:
+            # Create search filters
+            filters = SearchFlightsFilters(
+                departure_airport=departure_airport,
+                arrival_airport=arrival_airport,
+                departure_date=departure_date.strftime("%Y-%m-%d"),
+                passenger_info=PassengerInfo(adults=num_adults),
+                seat_type=seat_type,
+                stops=stops,
+                sort_by=sort_by,
+            )
+
+            # Show searching message
+            with st.spinner("Searching for flights..."):
+                # Perform search
+                search = SearchFlights()
+                results = search.search(filters)
+
+                # Search for date prices (4 weeks before and after)
+                date_from = departure_date - timedelta(weeks=4)
+                date_to = departure_date + timedelta(weeks=4)
+
+                date_filters = DateSearchFilters(
+                    departure_airport=departure_airport,
+                    arrival_airport=arrival_airport,
+                    from_date=date_from.strftime("%Y-%m-%d"),
+                    to_date=date_to.strftime("%Y-%m-%d"),
+                    passenger_info=PassengerInfo(adults=num_adults),
+                    seat_type=seat_type,
+                    stops=stops,
+                    flight_segments=[
+                        FlightSegment(
+                            departure_airport=[[departure_airport, 0]],
+                            arrival_airport=[[arrival_airport, 0]],
+                            travel_date=date_from.strftime("%Y-%m-%d"),
+                        )
+                    ],
+                )
+
+                date_search = SearchDates()
+                date_results = date_search.search(date_filters)
+
+            if results:
+                # Convert results to DataFrame for better display
+                flights_data = []
+                for flight in results:
+                    for leg in flight.legs:
+                        flights_data.append(
+                            {
+                                "Airline": leg.airline.value,
+                                "Flight": leg.flight_number,
+                                "From": leg.departure_airport.value,
+                                "To": leg.arrival_airport.value,
+                                "Departure": leg.departure_datetime.strftime("%H:%M"),
+                                "Arrival": leg.arrival_datetime.strftime("%H:%M"),
+                                "Duration": f"{leg.duration} mins",
+                                "Price": f"${flight.price:,.2f}",
+                                "Stops": flight.stops,
+                            }
+                        )
+
+                df = pd.DataFrame(flights_data)
+
+                # Display results in a nice table
+                st.subheader(f"Found {len(results)} flights")
+                st.dataframe(
+                    df,
+                    column_config={
+                        "Airline": st.column_config.TextColumn("Airline"),
+                        "Flight": st.column_config.TextColumn("Flight #"),
+                        "From": st.column_config.TextColumn("From"),
+                        "To": st.column_config.TextColumn("To"),
+                        "Departure": st.column_config.TextColumn("Departure"),
+                        "Arrival": st.column_config.TextColumn("Arrival"),
+                        "Duration": st.column_config.TextColumn("Duration"),
+                        "Price": st.column_config.TextColumn("Price"),
+                        "Stops": st.column_config.NumberColumn("Stops"),
+                    },
+                    hide_index=True,
+                    use_container_width=True,
+                )
+
+                # Display price trend chart
+                if date_results:
+                    st.subheader("Price Trends")
+                    date_prices = {result.date.date(): result.price for result in date_results}
+
+                    df_prices = pd.DataFrame(
+                        list(date_prices.items()), columns=["Date", "Price"]
+                    ).set_index("Date")
+
+                    st.line_chart(df_prices, use_container_width=True)
+
+                    # Show min/max prices
+                    min_price = min(date_prices.values())
+                    max_price = max(date_prices.values())
+                    min_date = min(date_prices.items(), key=lambda x: x[1])[0]
+
+                    st.info(
+                        "💰 Lowest price: ${:,.2f} on {}".format(
+                            min_price, min_date.strftime("%B %d, %Y")
+                        )
+                    )
+                    st.info(
+                        "📈 Highest price: ${:,.2f} on {}".format(
+                            max_price,
+                            max(date_prices.items(), key=lambda x: x[1])[0].strftime("%B %d, %Y"),
+                        )
+                    )
+            else:
+                st.warning(
+                    "No flights found for the selected criteria. Try different dates or airports."
+                )
+        except Exception as e:
+            st.error(f"An error occurred while searching for flights: {str(e)}")

fli/app/utils.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+def format_enum(enum: Enum) -> str:
+    """Format an enum value for display in a dropdown."""
+    return " ".join(enum.name.split("_")).title()

fli/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI module for the fli package."""
+
+from fli.cli.main import cli
+
+__all__ = ["cli"]

fli/cli/commands/__init__.py

@@ -0,0 +1,6 @@
+"""Command functions for the CLI."""
+
+from fli.cli.commands.cheap import cheap
+from fli.cli.commands.search import search
+
+__all__ = ["search", "cheap"]

fli/cli/commands/cheap.py

@@ -0,0 +1,218 @@
+from datetime import datetime, timedelta
+from typing import Annotated
+
+import typer
+
+from fli.cli.enums import DayOfWeek
+from fli.cli.utils import (
+    display_date_results,
+    filter_dates_by_days,
+    parse_airlines,
+    parse_stops,
+    validate_date,
+    validate_time_range,
+)
+from fli.models import (
+    Airport,
+    DateSearchFilters,
+    FlightSegment,
+    PassengerInfo,
+    SeatType,
+    TimeRestrictions,
+)
+from fli.search import SearchDates
+
+
+def cheap(
+    from_airport: Annotated[str, typer.Argument(help="Departure airport code (e.g., JFK)")],
+    to_airport: Annotated[str, typer.Argument(help="Arrival airport code (e.g., LHR)")],
+    from_date: Annotated[
+        str, typer.Option("--from", help="Start date (YYYY-MM-DD)", callback=validate_date)
+    ] = (datetime.now() + timedelta(days=1)).strftime("%Y-%m-%d"),
+    to_date: Annotated[
+        str, typer.Option("--to", help="End date (YYYY-MM-DD)", callback=validate_date)
+    ] = (datetime.now() + timedelta(days=60)).strftime("%Y-%m-%d"),
+    airlines: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--airlines",
+            "-a",
+            help="List of airline codes (e.g., BA KL)",
+        ),
+    ] = None,
+    seat: Annotated[
+        str,
+        typer.Option(
+            "--class",
+            "-c",
+            help="Seat type (ECONOMY, PREMIUM_ECONOMY, BUSINESS, FIRST)",
+        ),
+    ] = "ECONOMY",
+    stops: Annotated[
+        str,
+        typer.Option(
+            "--stops",
+            "-s",
+            help="Maximum number of stops (ANY, 0 for non-stop, 1 for one stop, 2+ for two stops)",
+        ),
+    ] = "ANY",
+    sort: Annotated[
+        bool,
+        typer.Option(
+            "--sort",
+            help="Sort results by price (lowest to highest)",
+        ),
+    ] = False,
+    monday: Annotated[
+        bool,
+        typer.Option(
+            "--monday",
+            "-mon",
+            help="Include Mondays in results",
+        ),
+    ] = False,
+    tuesday: Annotated[
+        bool,
+        typer.Option(
+            "--tuesday",
+            "-tue",
+            help="Include Tuesdays in results",
+        ),
+    ] = False,
+    wednesday: Annotated[
+        bool,
+        typer.Option(
+            "--wednesday",
+            "-wed",
+            help="Include Wednesdays in results",
+        ),
+    ] = False,
+    thursday: Annotated[
+        bool,
+        typer.Option(
+            "--thursday",
+            "-thu",
+            help="Include Thursdays in results",
+        ),
+    ] = False,
+    friday: Annotated[
+        bool,
+        typer.Option(
+            "--friday",
+            "-fri",
+            help="Include Fridays in results",
+        ),
+    ] = False,
+    saturday: Annotated[
+        bool,
+        typer.Option(
+            "--saturday",
+            "-sat",
+            help="Include Saturdays in results",
+        ),
+    ] = False,
+    sunday: Annotated[
+        bool,
+        typer.Option(
+            "--sunday",
+            "-sun",
+            help="Include Sundays in results",
+        ),
+    ] = False,
+    time: Annotated[
+        str | None,
+        typer.Option(
+            "--time",
+            "-t",
+            help="Time range in 24h format (e.g., 6-20)",
+            callback=validate_time_range,
+        ),
+    ] = None,
+):
+    """Find the cheapest dates to fly between two airports.
+
+    Example:
+        fli cheap LAX MIA --seat BUSINESS --stops NON_STOP --friday
+
+    """
+    try:
+        # Parse parameters
+        departure_airport = getattr(Airport, from_airport.upper())
+        arrival_airport = getattr(Airport, to_airport.upper())
+        seat_type = getattr(SeatType, seat.upper())
+        max_stops = parse_stops(stops)
+
+        # Parse time restrictions
+        time_restrictions = None
+        if time:
+            if isinstance(time, tuple):
+                start_hour, end_hour = time
+            else:
+                start_hour, end_hour = map(int, time.split("-"))
+            time_restrictions = TimeRestrictions(
+                earliest_departure=start_hour,
+                latest_departure=end_hour,
+                earliest_arrival=None,
+                latest_arrival=None,
+            )
+
+        # Create flight segment
+        flight_segment = FlightSegment(
+            departure_airport=[[departure_airport, 0]],
+            arrival_airport=[[arrival_airport, 0]],
+            travel_date=from_date,
+            time_restrictions=time_restrictions,
+        )
+
+        # Create search filters
+        filters = DateSearchFilters(
+            passenger_info=PassengerInfo(adults=1),
+            flight_segments=[flight_segment],
+            stops=max_stops,
+            seat_type=seat_type,
+            airlines=parse_airlines(airlines),
+            from_date=from_date,
+            to_date=to_date,
+        )
+
+        # Perform search
+        search_client = SearchDates()
+        dates = search_client.search(filters)
+
+        if not dates:
+            typer.echo("No flights found for these dates.")
+            raise typer.Exit(1)
+
+        # Filter by days if any day filters are specified
+        selected_days = []
+        if monday:
+            selected_days.append(DayOfWeek.MONDAY)
+        if tuesday:
+            selected_days.append(DayOfWeek.TUESDAY)
+        if wednesday:
+            selected_days.append(DayOfWeek.WEDNESDAY)
+        if thursday:
+            selected_days.append(DayOfWeek.THURSDAY)
+        if friday:
+            selected_days.append(DayOfWeek.FRIDAY)
+        if saturday:
+            selected_days.append(DayOfWeek.SATURDAY)
+        if sunday:
+            selected_days.append(DayOfWeek.SUNDAY)
+
+        dates = filter_dates_by_days(dates, selected_days)
+
+        if not dates:
+            typer.echo("No flights found for the selected days.")
+            raise typer.Exit(1)
+
+        # Sort dates by price if sort flag is enabled
+        if sort:
+            dates.sort(key=lambda x: x.price)
+
+        # Display results
+        display_date_results(dates)
+
+    except (AttributeError, ValueError) as e:
+        typer.echo(f"Error: {str(e)}")
+        raise typer.Exit(1) from e

fli/cli/commands/search.py

@@ -0,0 +1,135 @@
+from typing import Annotated
+
+import typer
+
+from fli.cli.utils import (
+    display_flight_results,
+    filter_flights_by_airlines,
+    filter_flights_by_time,
+    parse_airlines,
+    parse_stops,
+    validate_date,
+    validate_time_range,
+)
+from fli.models import Airport, PassengerInfo, SeatType, SortBy
+from fli.search import SearchFlights, SearchFlightsFilters
+
+
+def search_flights(
+    from_airport: str,
+    to_airport: str,
+    date: str,
+    time: tuple[int, int] | None = None,
+    airlines: list[str] | None = None,
+    seat: str = "ECONOMY",
+    stops: str = "ANY",
+    sort: str = "CHEAPEST",
+):
+    """Core flight search functionality."""
+    try:
+        # Parse parameters
+        departure_airport = getattr(Airport, from_airport.upper())
+        arrival_airport = getattr(Airport, to_airport.upper())
+        seat_type = getattr(SeatType, seat.upper())
+        max_stops = parse_stops(stops)
+        sort_by = getattr(SortBy, sort.upper())
+
+        # Create search filters
+        filters = SearchFlightsFilters(
+            departure_airport=departure_airport,
+            arrival_airport=arrival_airport,
+            departure_date=date,
+            passenger_info=PassengerInfo(adults=1),
+            seat_type=seat_type,
+            stops=max_stops,
+            sort_by=sort_by,
+        )
+
+        # Perform search
+        search_client = SearchFlights()
+        flights = search_client.search(filters)
+
+        if not flights:
+            typer.echo("No flights found.")
+            raise typer.Exit(1)
+
+        # Apply time filter if specified
+        if time:
+            start_hour, end_hour = time
+            flights = filter_flights_by_time(flights, start_hour, end_hour)
+
+        # Apply airline filter if specified
+        airline_list = parse_airlines(airlines)
+        if airline_list:
+            flights = filter_flights_by_airlines(flights, airline_list)
+
+        # Display results
+        display_flight_results(flights)
+
+    except (AttributeError, ValueError) as e:
+        typer.echo(f"Error: {str(e)}")
+        raise typer.Exit(1) from e
+
+
+def search(
+    from_airport: Annotated[str, typer.Argument(help="Departure airport code (e.g., JFK)")],
+    to_airport: Annotated[str, typer.Argument(help="Arrival airport code (e.g., LHR)")],
+    date: Annotated[str, typer.Argument(help="Travel date (YYYY-MM-DD)", callback=validate_date)],
+    time: Annotated[
+        str | None,
+        typer.Option(
+            "--time",
+            "-t",
+            help="Time range in 24h format (e.g., 6-20)",
+            callback=validate_time_range,
+        ),
+    ] = None,
+    airlines: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--airlines",
+            "-a",
+            help="List of airline codes (e.g., BA KL)",
+        ),
+    ] = None,
+    seat: Annotated[
+        str,
+        typer.Option(
+            "--class",
+            "-c",
+            help="Seat type (ECONOMY, PREMIUM_ECONOMY, BUSINESS, FIRST)",
+        ),
+    ] = "ECONOMY",
+    stops: Annotated[
+        str,
+        typer.Option(
+            "--stops",
+            "-s",
+            help="Maximum number of stops (ANY, 0 for non-stop, 1 for one stop, 2+ for two stops)",
+        ),
+    ] = "ANY",
+    sort: Annotated[
+        str,
+        typer.Option(
+            "--sort",
+            "-o",
+            help="Sort results by (CHEAPEST, DURATION, DEPARTURE_TIME, ARRIVAL_TIME)",
+        ),
+    ] = "CHEAPEST",
+):
+    """Search for flights with flexible filtering options.
+
+    Example:
+        fli search JFK LHR 2025-10-25 --time 6-20 --airlines BA KL --stops NON_STOP
+
+    """
+    search_flights(
+        from_airport=from_airport,
+        to_airport=to_airport,
+        date=date,
+        time=time,
+        airlines=airlines,
+        seat=seat,
+        stops=stops,
+        sort=sort,
+    )

fli/cli/commands/streamlit.py

@@ -0,0 +1,16 @@
+"""App command implementation."""
+
+import sys
+from pathlib import Path
+
+import streamlit.web.cli as stcli
+
+
+def streamlit() -> None:
+    """Launch the Streamlit app interface."""
+    # Get the path to main.py
+    app_path = Path(__file__).parents[2].joinpath("app", "main.py")
+
+    # Run the Streamlit app
+    sys.argv = ["streamlit", "run", str(app_path), "--server.port", "3600"]
+    sys.exit(stcli.main())

fli/cli/console.py

@@ -0,0 +1,5 @@
+"""Console module for the CLI."""
+
+from rich.console import Console
+
+console = Console()

fli/cli/enums.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class DayOfWeek(Enum):
+    """Days of the week."""
+
+    MONDAY = "monday"
+    TUESDAY = "tuesday"
+    WEDNESDAY = "wednesday"
+    THURSDAY = "thursday"
+    FRIDAY = "friday"
+    SATURDAY = "saturday"
+    SUNDAY = "sunday"

fli/cli/main.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+
+import sys
+
+import typer
+
+from fli.cli.commands.cheap import cheap
+from fli.cli.commands.search import search
+from fli.cli.commands.streamlit import streamlit
+
+app = typer.Typer(
+    help="Search for flights using Google Flights data",
+    add_completion=True,
+)
+
+# Register commands
+app.command(name="app")(streamlit)
+app.command(name="cheap")(cheap)
+app.command(name="search")(search)
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context):
+    """Search for flights using Google Flights data.
+
+    If no command is provided, the search command will be used.
+    """
+    # If no command is provided, show help
+    if ctx.invoked_subcommand is None:
+        ctx.get_help()
+        raise typer.Exit()
+
+
+def cli():
+    """Entry point for the CLI that handles default command."""
+    args = sys.argv[1:]
+    if not args:
+        app()
+        return
+
+    # If the first argument isn't a command, treat as search
+    if args[0] not in ["app", "cheap", "search", "--help", "-h"]:
+        sys.argv.insert(1, "search")
+
+    app()
+
+
+if __name__ == "__main__":
+    cli()