models.py

from typing import List, Dict, Any  # Import necessary type hints

class Airline:
    """
    Airline object. Represents a single airline.
    Attributes:
        iata: the airline's IATA code.
        name: name of the airline
    """
    def __init__(self, iata: str, name: str):
        self.iata = iata
        self.name = name

    @classmethod
    def from_dict(cls, data: Dict[str, str]):
        """
        Deserializes the airline from a dictionary (JSON)

        Args:
            data (Dict[str, str]): the dictionary (JSON)

        Returns:
            Instance of Airline
        """
        return cls(
            iata=data['iata'],
            name=data['name']
        )

    def Airline_to_json_string(self):
        """
        Serializes the airline into a JSON string.
        Returns:
            str: the JSON representation of the airline
        """
        return f"Airline(iata='{self.iata}', name='{self.name}')"

class Route:
    """
    Route object, represents a single flight route (edge).
    Attributes:
        iata (str): the airport's iata code.
        km (int): the distance in kilometers.
        min (int): the flight duration in minutes.
        Airlines (List[Airline]): a list of airlines that take this route.
    """
    def __init__(self, iata: str, km: int, min: int, Airlines: List[Airline]):
        self.iata = iata  # Destination airport IATA code
        self.km = km  # Distance in kilometers
        self.min = min  # Flight duration in minutes
        self.Airlines = Airlines  # List of Airlines operating this route


    @classmethod
    # Deserializes a Route from a dictionary. 
    def from_dict(cls, data: Dict[str, Any]):
        """
        Deserializes the route from a dictionary (JSON)

        Args:
            data (Dict[str, Any]): the dictionary (JSON)

        Returns:
            An instance of Route.
        """
        Airlines = []
        for carrier in data['carriers']:
            Airlines.append(Airline.from_dict(carrier))
        # return the Route object. Example: Route(iata='GLA', km=0, min=0, Airlines=['BA', 'FR'])
        return cls(
            iata=data['iata'],
            km=data['km'],
            min=data['min'],
            Airlines=Airlines
        )

    def route_to_json_string(self):
        """
        Serializes the route to a JSON string.
        Returns:
            str: the JSON representation of the route
        """
        return (f"Route(iata='{self.iata}', km={self.km}, min={self.min}, "
                f"Airlines={[c.iata for c in self.Airlines]})")  # Show IATA codes for brevity

class Airport:
    """
    Airport object. Represents a single airport (vertex/node).
    Attributes:
        city_name (str): The full name of the city where this airport is from.
        continent (str): The full name of the continent where the airport is located.
        country (str): The full name of the country where the airport is located.
        country_code (str): The 2 Character ISO 3166-1 name of the country where the airport is located.
        display_name (str): The long display name of the airport.
        elevation (str): The elevation of the aiport above MSL.
        iata (str): The airport's iata code.
        icao (str): The airport's icao code.
        latitude (str): The latitude of the airport represented in Decimal Degrees as a string.
        longitude (str): The longitude of the airport represented in Decimal Degrees as a string.
        name (str): The full name of the airport.
        routes (List[Route]): a list of routes out of this airport..
    """
    def __init__(self, city_name: str, continent: str, country: str, country_code: str,
                 display_name: str, elevation: int, iata: str, icao: str,
                 latitude: float, longitude: float, name: str, routes: List[Route]):

        self.city_name = city_name
        self.continent = continent
        self.country = country
        self.country_code = country_code
        self.display_name = display_name
        self.elevation = elevation
        self.iata = iata
        self.icao = icao
        self.latitude = latitude
        self.longitude = longitude
        self.name = name
        self.routes = routes  # List of outgoing routes

    @classmethod
    def from_dict(cls, iata: str, data: Dict[str, Any]):
        """
        Deserializes the Airport from a dictionary (JSON)
        Args:
            data (Dict[str, Any]): the dictionary (JSON)
        Returns:
            An instance of Airport.
        """
        routes = [Route.from_dict(route_data) for route_data in data['routes']]
        if data['latitude'] is None or data['longitude'] is None:
            return None
        return cls(
            city_name=data['city_name'],
            continent=data['continent'],
            country=data['country'],
            country_code=data['country_code'],
            display_name=data['display_name'],
            elevation=data['elevation'],
            iata=iata,  # Use the key from the JSON as the IATA code
            icao=data['icao'],
            latitude=float(data['latitude']),  # Convert to float
            longitude=float(data['longitude']), # Convert to float
            name=data['name'],
            routes=routes
        )

    def __repr__(self):
        return f"Airport(iata='{self.iata}', name='{self.name}', routes={len(self.routes)})"