Flyan 0.1.0__py3-none-any.whl

flyan/misc.py

@@ -0,0 +1,132 @@
+import json
+from datetime import datetime
+from typing import Optional, Dict
+
+from pydantic import BaseModel, field_validator
+
+currencies: Dict[str, str] = json.load(open("./currencies.json", encoding="utf-8"))
+stations: Dict[str, str] = json.load(open("./stations.json", encoding="utf-8"))
+
+
+class Airport(BaseModel):
+    country_name: str
+    iata_code: str
+    name: str
+    seo_name: str
+    city_name: str
+    city_code: str
+    city_country_code: str
+
+
+class Flight(BaseModel):
+    departure_airport: Airport
+    arrival_airport: Airport
+    departure_date: datetime
+    arrival_date: datetime
+    price: float
+    currency: str
+    flight_key: str
+    flight_number: str
+    previous_price: Optional[str | float]
+
+
+class ReturnFlight(BaseModel):
+    outbound: Flight
+    inbound: Flight
+    summary_price: float
+    summary_currency: str
+    previous_price: str | float
+
+
+class FlightSearchParams(BaseModel):
+    """Parameters for flight searches"""
+
+    from_airport: str
+    from_date: datetime
+    to_date: datetime
+    destination_country: Optional[str] = None
+    max_price: Optional[int] = None
+    to_airport: Optional[str] = None
+    departure_time_from: Optional[str] = "00:00"
+    departure_time_to: Optional[str] = "23:59"
+
+    @field_validator("from_airport")
+    def validate_airport(cls, v: str):
+
+        if v not in stations.keys():
+            raise ValueError("Airport code must be a 3-letter IATA code")
+
+        return v.upper()
+
+    @field_validator("from_date", "to_date")
+    def validate_dates(cls, v: datetime):
+        if v < datetime.now():
+            raise ValueError("Date from or to cannot be in the past")
+
+        return v
+
+    @field_validator("max_price")
+    def validate_price(cls, v: int | None):
+        if v is None:
+            return v
+
+        if v <= 0:
+            raise ValueError("Price can't be negative")
+
+        return v
+
+    def to_api_params(self) -> Dict[str, str | int]:
+        """Convert the parameters to the format expected by the Ryanair API"""
+        params: Dict[str, str | int] = {
+            "departureAirportIataCode": self.from_airport,
+            "outboundDepartureDateFrom": self.from_date.date().isoformat(),
+            "outboundDepartureDateTo": self.to_date.date().isoformat(),
+            "outboundDepartureTimeFrom": self.departure_time_from or "00:00",
+            "outboundDepartureTimeTo": self.departure_time_to or "23:59",
+        }
+
+        if self.destination_country:
+            params["arrivalCountryCode"] = self.destination_country
+
+        if self.max_price:
+            params["priceValueTo"] = self.max_price
+
+        if self.to_airport:
+            params["arrivalAirportIataCode"] = self.to_airport
+
+        return params
+
+
+class ReturnFlightSearchParams(FlightSearchParams):
+    """Parameters for return flight searches"""
+
+    return_date_from: datetime
+    return_date_to: datetime
+    inbound_departure_time_from: Optional[str] = "00:00"
+    inbound_departure_time_to: Optional[str] = "23:59"
+
+    @field_validator("return_date_from", "return_date_to")
+    @classmethod
+    def validate_return_dates(cls, v: datetime) -> datetime:
+        # Note: In Pydantic v2, cross-field validation should be done with model_validator
+        # This is a simplified version - ideally use model_validator for cross-field validation
+        return v
+
+    def to_api_params(self) -> Dict[str, str | int]:
+        """Convert the parameters to the format expected by the Ryanair API"""
+        params = super().to_api_params()
+
+        additional_params = {
+            "inboundDepartureDateFrom": self.return_date_from.date().isoformat(),
+            "inboundDepartureDateTo": self.return_date_to.date().isoformat(),
+        }
+
+        if self.inbound_departure_time_from:
+            additional_params["inboundDepartureTimeFrom"] = (
+                self.inbound_departure_time_from
+            )
+        if self.inbound_departure_time_to:
+            additional_params["inboundDepartureTimeTo"] = self.inbound_departure_time_to
+
+        params.update(additional_params)
+        return params

flyan/ryanair.py

@@ -0,0 +1,158 @@
+import logging
+from datetime import datetime
+from typing import Dict, Any
+
+import httpx
+from fake_useragent.fake import UserAgent
+from tenacity import (
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from flyan.misc import (
+    Airport,
+    Flight,
+    FlightSearchParams,
+    ReturnFlight,
+    currencies,
+)
+
+ua = UserAgent()
+logger = logging.getLogger("Flyan")
+if not logger.handlers:
+    logger.setLevel(logging.INFO)
+
+    console_handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+        "%(asctime)s.%(msecs)03d %(levelname)s:%(message)s", datefmt="%Y-%m-%d %I:%M:%S"
+    )
+
+    console_handler.setFormatter(formatter)
+    logger.addHandler(console_handler)
+
+
+class RyanairException(Exception):
+    def __init__(self, message: str):
+        super().__init__(f"Ryanair API: {message}")
+
+
+class RyanAir:
+    """
+    Create a RyanAir instance
+
+    :param str currency: Preferred currency
+    """
+
+    BASE_SERVICES_API_URL = "https://services-api.ryanair.com/farfnd/v4"
+    AGGREGATE_URL = "https://www.ryanair.com/api/views/locate/3/aggregate/all/en"
+
+    def __init__(self, currency: str = "EUR"):
+        self.client = httpx.Client(
+            headers={
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+                "Accept-Encoding": "gzip, deflate, br, zstd",
+                "Accept-Language": "en-GB,en;q=0.9",
+                "Cache-Control": "no-cache",
+                "Pragma": "no-cache",
+                "Priority": "u=0, i",
+                "Upgrade-Insecure-Requests": "1",
+                "User-Agent": ua.random,
+            },
+            follow_redirects=True,
+        )
+
+        self.__get("https://www.ryanair.com")
+
+        if currency in currencies.keys():
+            self.currency = currency
+
+        else:
+            self.currency = "EUR"
+
+    def __del__(self):
+        self.client.close()
+
+    @retry(
+        stop=stop_after_attempt(5),  # Retry up to 5 times
+        wait=wait_exponential(),
+        retry=retry_if_exception_type(Exception),
+        reraise=True,  # Raise the exception after retries are exhausted
+    )
+    def __get(self, url: str, params: dict[str, str] = {}) -> httpx.Response:
+        """
+        Send a GET request to url
+
+        :param str url: The url to GET
+        :param dict params: URL Parameters for the query
+        :return httpx.Response: Response object
+        :raises httpx.HTTPStatusError: If one occurred
+        """
+        response = self.client.get(url, params=params)
+        response.raise_for_status()
+        return response
+
+    def __parse_airport(self, airport: Dict[str, Any]) -> Airport:
+        return Airport(
+            country_name=airport["countryName"],
+            iata_code=airport["iataCode"],
+            name=airport["name"],
+            seo_name=airport["seoName"],
+            city_name=airport["city"]["name"],
+            city_code=airport["city"]["code"],
+            city_country_code=airport["city"]["countryCode"],
+        )
+
+    def __parse_fare(self, fare: Dict[str, Any], k: str = "outbound") -> Flight:
+        dep_date = datetime.fromisoformat(fare[k]["departureDate"])
+        arr_date = datetime.fromisoformat(fare[k]["arrivalDate"])
+
+        return Flight(
+            departure_airport=self.__parse_airport(fare[k]["departureAirport"]),
+            arrival_airport=self.__parse_airport(fare[k]["arrivalAirport"]),
+            departure_date=dep_date,
+            arrival_date=arr_date,
+            price=fare[k]["price"]["value"],
+            currency=fare[k]["price"]["currencyCode"],
+            flight_key=fare[k]["flightKey"],
+            flight_number=fare[k]["flightNumber"],
+            previous_price=fare[k].get("previousPrice", None),
+        )
+
+    def __parse_return_fare(self, fare: Dict[str, Any]) -> ReturnFlight:
+        outbound = self.__parse_fare(fare, "outbound")
+        inbound = self.__parse_fare(fare, "inbound")
+
+        return ReturnFlight(
+            outbound=outbound,
+            inbound=inbound,
+            summary_price=fare["summary"]["price"]["value"],
+            summary_currency=fare["summary"]["price"]["currencyCode"],
+            previous_price=fare.get("previousPrice") or 0,
+        )
+
+    def get_oneways(self, params: FlightSearchParams) -> list[Flight]:
+        """
+        Get oneways
+        """
+        print("Getting oneways")
+        url = f"{self.BASE_SERVICES_API_URL}/oneWayFares"
+
+        try:
+            r = self.__get(url, params.to_api_params())
+            if not r.is_success:
+                return []
+
+            fares = r.json()["fares"]
+            flights = [self.__parse_fare(f) for f in fares]
+
+            return flights
+
+        except httpx.HTTPError:
+            logger.error(f"A HTTP Error occured trying to get {url}", exc_info=True)
+            return []
+
+        except KeyError as KE:
+            print(KE)
+            return []

flyan-0.1.0.dist-info/METADATA

@@ -0,0 +1,282 @@
+Metadata-Version: 2.4
+Name: Flyan
+Version: 0.1.0
+Summary: Open source unofficial API wrappper to get flight data from RyanAir.
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: fake-useragent>=1.5.1
+Requires-Dist: httpx>=0.27.2
+Requires-Dist: pydantic>=2.9.2
+Requires-Dist: tenacity>=9.0.0
+
+# Flyan SDK
+
+An open-source unofficial API wrapper to get flight data from Ryanair.
+
+## Installation
+
+```bash
+pip install flyan
+```
+
+Or using uv:
+
+```bash
+uv add flyan
+```
+
+## Quick Start
+
+```python
+from datetime import datetime
+from flyan import RyanAir, FlightSearchParams
+
+# Initialize the client
+client = RyanAir(currency="EUR")
+
+# Set up search parameters
+search_params = FlightSearchParams(
+    from_airport="DUB",  # Dublin
+    to_airport="BCN",    # Barcelona
+    from_date=datetime(2025, 8, 15),
+    to_date=datetime(2025, 8, 20),
+    max_price=200
+)
+
+# Search for one-way flights
+flights = client.get_oneways(search_params)
+
+# Display results
+for flight in flights:
+    print(f"Flight {flight.flight_number}: {flight.departure_airport.name} → {flight.arrival_airport.name}")
+    print(f"Departure: {flight.departure_date}")
+    print(f"Price: {flight.price} {flight.currency}")
+    print("---")
+```
+
+## API Reference
+
+### RyanAir Class
+
+#### Constructor
+
+```python
+RyanAir(currency: str = "EUR")
+```
+
+Creates a new RyanAir client instance.
+
+**Parameters:**
+
+- `currency` (str, optional): Preferred currency for pricing. Defaults to "EUR". Must be a valid currency code from the supported currencies list.
+
+**Example:**
+
+```python
+# Default EUR currency
+client = RyanAir()
+
+# Specific currency
+client = RyanAir(currency="USD")
+```
+
+#### Methods
+
+##### `get_oneways(params: FlightSearchParams) -> list[Flight]`
+
+Search for one-way flights.
+
+**Parameters:**
+
+- `params` (FlightSearchParams): Search parameters
+
+**Returns:**
+
+- `list[Flight]`: List of available flights
+
+### FlightSearchParams Class
+
+Parameters for searching flights.
+
+```python
+FlightSearchParams(
+    from_airport: str,
+    from_date: datetime,
+    to_date: datetime,
+    destination_country: Optional[str] = None,
+    max_price: Optional[int] = None,
+    to_airport: Optional[str] = None,
+    departure_time_from: Optional[str] = "00:00",
+    departure_time_to: Optional[str] = "23:59"
+)
+```
+
+**Parameters:**
+
+- `from_airport` (str): IATA code of departure airport (e.g., "DUB")
+- `from_date` (datetime): Earliest departure date
+- `to_date` (datetime): Latest departure date
+- `destination_country` (str, optional): Country code for destination
+- `max_price` (int, optional): Maximum price filter
+- `to_airport` (str, optional): IATA code of arrival airport
+- `departure_time_from` (str, optional): Earliest departure time (HH:MM format)
+- `departure_time_to` (str, optional): Latest departure time (HH:MM format)
+
+**Example:**
+
+```python
+from datetime import datetime
+
+params = FlightSearchParams(
+    from_airport="DUB",
+    from_date=datetime(2025, 8, 15),
+    to_date=datetime(2025, 8, 20),
+    to_airport="BCN",
+    max_price=150,
+    departure_time_from="08:00",
+    departure_time_to="18:00"
+)
+```
+
+### ReturnFlightSearchParams Class
+
+Extended parameters for return flight searches.
+
+```python
+ReturnFlightSearchParams(
+    # All FlightSearchParams fields plus:
+    return_date_from: datetime,
+    return_date_to: datetime,
+    inbound_departure_time_from: Optional[str] = "00:00",
+    inbound_departure_time_to: Optional[str] = "23:59"
+)
+```
+
+## Data Models
+
+### Flight
+
+Represents a single flight.
+
+**Attributes:**
+
+- `departure_airport` (Airport): Departure airport information
+- `arrival_airport` (Airport): Arrival airport information
+- `departure_date` (datetime): Departure date and time
+- `arrival_date` (datetime): Arrival date and time
+- `price` (float): Flight price
+- `currency` (str): Price currency
+- `flight_key` (str): Unique flight identifier
+- `flight_number` (str): Flight number
+- `previous_price` (Optional[str | float]): Previous price if available
+
+### Airport
+
+Represents airport information.
+
+**Attributes:**
+
+- `country_name` (str): Country name
+- `iata_code` (str): IATA airport code
+- `name` (str): Airport name
+- `seo_name` (str): SEO-friendly name
+- `city_name` (str): City name
+- `city_code` (str): City code
+- `city_country_code` (str): Country code
+
+### ReturnFlight
+
+Represents a return flight booking.
+
+**Attributes:**
+
+- `outbound` (Flight): Outbound flight
+- `inbound` (Flight): Return flight
+- `summary_price` (float): Total price for both flights
+- `summary_currency` (str): Currency for total price
+- `previous_price` (str | float): Previous total price if available
+
+## Examples
+
+### Search by Country
+
+```python
+# Search flights to any airport in Spain
+params = FlightSearchParams(
+    from_airport="DUB",
+    destination_country="ES",
+    from_date=datetime(2025, 9, 1),
+    to_date=datetime(2025, 9, 7)
+)
+
+flights = client.get_oneways(params)
+```
+
+### Filter by Time and Price
+
+```python
+# Morning flights under €100
+params = FlightSearchParams(
+    from_airport="STN",  # London Stansted
+    to_airport="DUB",    # Dublin
+    from_date=datetime(2025, 8, 1),
+    to_date=datetime(2025, 8, 5),
+    max_price=100,
+    departure_time_from="06:00",
+    departure_time_to="12:00"
+)
+
+flights = client.get_oneways(params)
+```
+
+### Error Handling
+
+```python
+from flyan import RyanairException
+
+try:
+    flights = client.get_oneways(params)
+    if not flights:
+        print("No flights found for the given criteria")
+except RyanairException as e:
+    print(f"Ryanair API error: {e}")
+except Exception as e:
+    print(f"Unexpected error: {e}")
+```
+
+## Supported Airports
+
+The SDK supports all airports in Ryanair's network. Airport codes must be valid 3-letter IATA codes. You can find the complete list of supported airports in the `stations.json` file.
+
+Popular airports include:
+
+- **DUB** - Dublin
+- **STN** - London Stansted
+- **BCN** - Barcelona
+- **MAD** - Madrid
+- **FCO** - Rome Fiumicino
+- **BRU** - Brussels
+- **AMS** - Amsterdam
+
+## Supported Currencies
+
+The SDK supports multiple currencies. Some popular ones include:
+
+- **EUR** - Euro
+- **USD** - US Dollar
+- **GBP** - British Pound
+- **CHF** - Swiss Franc
+
+See `currencies.json` for the complete list.
+
+## Rate Limiting
+
+The SDK includes automatic retry logic with exponential backoff to handle rate limiting and temporary API issues. It will retry failed requests up to 5 times before giving up.
+
+## Contributing
+
+This is an open-source project. Contributions are welcome!
+
+## Disclaimer
+
+This is an unofficial API wrapper and is not affiliated with Ryanair. Use at your own risk and ensure you comply with Ryanair's terms of service.

flyan-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+flyan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flyan/misc.py,sha256=dXeEyDyOC1SAndtug3lLo8grTwtx5Ds7soCiOrKINWo,4081
+flyan/ryanair.py,sha256=O6kOZNhQU6By6erO3bvngmMCKBvsR6CcLMe7r8pHryU,5003
+flyan-0.1.0.dist-info/METADATA,sha256=bPwWR2pF7AtJ8kglZQW1PDXx_CI4ieN_W7gjSVvifX8,6643
+flyan-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flyan-0.1.0.dist-info/top_level.txt,sha256=yd55u-oMq-vqxqRE63e7Twfk3LO4LAvBwQ44ir2Wxbs,6
+flyan-0.1.0.dist-info/RECORD,,

flyan-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flyan-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+flyan