opensky-cli 0.1.0__py3-none-any.whl

opensky/providers/duffel.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+import logging
+
+import httpx
+from ratelimit import limits, sleep_and_retry
+
+from opensky.models import FlightLeg, FlightResult
+from opensky.providers import parse_iso_duration
+
+log = logging.getLogger(__name__)
+
+API_BASE = "https://api.duffel.com"
+
+CABIN_MAP: dict[str, str] = {
+    "economy": "economy",
+    "premium_economy": "premium_economy",
+    "business": "business",
+    "first": "first",
+}
+
+
+def _convert_offer(offer: dict, currency: str) -> FlightResult:
+    """Convert a Duffel offer dict to a FlightResult."""
+    price = float(offer.get("total_amount", 0))
+    offer_currency = offer.get("total_currency", currency)
+
+    legs: list[FlightLeg] = []
+    total_duration = 0
+
+    for slc in offer.get("slices", []):
+        for seg in slc.get("segments", []):
+            dep = seg.get("departing_at", "")
+            arr = seg.get("arriving_at", "")
+            dur = parse_iso_duration(seg.get("duration", ""))
+            total_duration += dur
+
+            carrier = seg.get("operating_carrier", {})
+            airline = carrier.get("iata_code", seg.get("marketing_carrier", {}).get("iata_code", ""))
+            flight_num = seg.get("operating_carrier_flight_number", seg.get("marketing_carrier_flight_number", ""))
+
+            legs.append(FlightLeg(
+                airline=airline,
+                flight_number=flight_num,
+                departure_airport=seg.get("origin", {}).get("iata_code", ""),
+                arrival_airport=seg.get("destination", {}).get("iata_code", ""),
+                departure_time=dep,
+                arrival_time=arr,
+                duration_minutes=dur,
+            ))
+
+    return FlightResult(
+        price=price,
+        currency=offer_currency,
+        duration_minutes=total_duration,
+        stops=max(len(legs) - 1, 0),
+        legs=legs,
+        provider="duffel",
+    )
+
+
+class DuffelProvider:
+    name = "duffel"
+
+    def __init__(self, token: str):
+        self._token = token
+        self._client = httpx.Client(
+            base_url=API_BASE,
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Duffel-Version": "v2",
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+            },
+            timeout=30.0,
+        )
+
+    @sleep_and_retry
+    @limits(calls=10, period=1)
+    def search(
+        self,
+        origin: str,
+        dest: str,
+        date: str,
+        cabin: str,
+        currency: str,
+        max_stops: int | None,
+    ) -> list[FlightResult]:
+        cabin_class = CABIN_MAP.get(cabin, "economy")
+
+        payload = {
+            "data": {
+                "slices": [
+                    {
+                        "origin": origin,
+                        "destination": dest,
+                        "departure_date": date,
+                    }
+                ],
+                "passengers": [{"type": "adult"}],
+                "cabin_class": cabin_class,
+                "currency": currency,
+                "return_offers": True,
+                "max_connections": max_stops if max_stops is not None else 2,
+            }
+        }
+
+        resp = self._client.post("/air/offer_requests", json=payload)
+        resp.raise_for_status()
+        data = resp.json().get("data", {})
+        offers = data.get("offers", [])
+
+        results = [_convert_offer(o, currency) for o in offers]
+
+        # Client-side stops filter (Duffel max_connections is 0-2)
+        if max_stops is not None:
+            results = [r for r in results if r.stops <= max_stops]
+
+        return results
+
+    def close(self) -> None:
+        self._client.close()

opensky/providers/google.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import Any
+
+from opensky._vendor.google_flights import (
+    FlightSearchFilters,
+    FlightSegment,
+    MaxStops,
+    PassengerInfo,
+    SeatType,
+    SearchFlights,
+    SortBy,
+)
+from opensky.models import FlightLeg, FlightResult
+
+SEAT_MAP: dict[str, SeatType] = {
+    "economy": SeatType.ECONOMY,
+    "premium_economy": SeatType.PREMIUM_ECONOMY,
+    "premium": SeatType.PREMIUM_ECONOMY,
+    "business": SeatType.BUSINESS,
+    "first": SeatType.FIRST,
+}
+
+STOPS_MAP: dict[int | None, MaxStops] = {
+    None: MaxStops.ANY,
+    0: MaxStops.NON_STOP,
+    1: MaxStops.ONE_STOP_OR_FEWER,
+    2: MaxStops.TWO_OR_FEWER_STOPS,
+}
+
+
+def _build_filters(
+    origin: str,
+    dest: str,
+    date: str,
+    seat: SeatType = SeatType.ECONOMY,
+    stops: MaxStops = MaxStops.ANY,
+) -> FlightSearchFilters:
+    return FlightSearchFilters(
+        flight_segments=[
+            FlightSegment(
+                departure_airport=[[origin, 0]],
+                arrival_airport=[[dest, 0]],
+                travel_date=date,
+            )
+        ],
+        passenger_info=PassengerInfo(adults=1),
+        seat_type=seat,
+        stops=stops,
+        sort_by=SortBy.CHEAPEST,
+    )
+
+
+def _convert_result(raw: Any, currency: str) -> FlightResult:
+    legs = []
+    for leg in raw.legs:
+        legs.append(FlightLeg(
+            airline=leg.airline,
+            flight_number=leg.flight_number,
+            departure_airport=leg.departure_airport,
+            arrival_airport=leg.arrival_airport,
+            departure_time=leg.departure_datetime.isoformat(),
+            arrival_time=leg.arrival_datetime.isoformat(),
+            duration_minutes=leg.duration,
+        ))
+
+    return FlightResult(
+        price=raw.price,
+        currency=currency,
+        duration_minutes=raw.duration,
+        stops=raw.stops,
+        legs=legs,
+        provider="google",
+    )
+
+
+class GoogleProvider:
+    name = "google"
+
+    def __init__(self, currency: str = "EUR", proxy: str | None = None):
+        self._currency = currency
+        self._proxy = proxy
+        self._api: SearchFlights | None = None
+
+    def _get_api(self) -> SearchFlights:
+        if self._api is None:
+            self._api = SearchFlights(currency=self._currency, proxy=self._proxy)
+        return self._api
+
+    def search(
+        self,
+        origin: str,
+        dest: str,
+        date: str,
+        cabin: str,
+        currency: str,
+        max_stops: int | None,
+    ) -> list[FlightResult]:
+        seat = SEAT_MAP.get(cabin, SeatType.ECONOMY)
+        stops = STOPS_MAP.get(max_stops, MaxStops.ANY)
+        filters = _build_filters(origin, dest, date, seat, stops)
+        api = self._get_api()
+        raw_results = api.search(filters)
+        if not raw_results:
+            return []
+        return [_convert_result(r, currency) for r in raw_results]
+
+    def close(self) -> None:
+        if self._api:
+            self._api.close()
+            self._api = None

opensky/safety.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import airportsdata
+
+from opensky.models import ConflictZone, FlaggedAirport, RiskAssessment, RiskLevel
+
+_BUNDLED_PATH = Path(__file__).parent / "data" / "conflict_zones.json"
+_CACHE_PATH = Path.home() / ".cache" / "opensky" / "conflict_zones.json"
+_CACHE_MAX_AGE = 7 * 24 * 3600  # 7 days
+
+_airports_db: dict[str, dict] | None = None
+_zones: list[ConflictZone] | None = None
+_country_risk: dict[str, tuple[RiskLevel, str]] | None = None
+_airport_risk: dict[str, tuple[RiskLevel, str]] | None = None
+
+
+def _get_airports_db() -> dict[str, dict]:
+    global _airports_db
+    if _airports_db is None:
+        _airports_db = airportsdata.load("IATA")
+    return _airports_db
+
+
+def airport_country(iata: str) -> str | None:
+    db = _get_airports_db()
+    info = db.get(iata)
+    return info["country"] if info else None
+
+
+def _load_zones_from_file(path: Path) -> list[ConflictZone]:
+    data = json.loads(path.read_text())
+    return [ConflictZone(**z) for z in data["zones"]]
+
+
+def load_zones(force_bundled: bool = False) -> list[ConflictZone]:
+    global _zones, _country_risk, _airport_risk
+
+    if _zones is not None and not force_bundled:
+        return _zones
+
+    # Prefer cached version if fresh
+    source = _BUNDLED_PATH
+    if not force_bundled and _CACHE_PATH.exists():
+        age = time.time() - _CACHE_PATH.stat().st_mtime
+        if age < _CACHE_MAX_AGE:
+            source = _CACHE_PATH
+
+    _zones = _load_zones_from_file(source)
+
+    # Build lookup tables
+    _country_risk = {}
+    _airport_risk = {}
+    for zone in _zones:
+        rl = zone.risk_level
+        for cc in zone.countries:
+            existing = _country_risk.get(cc)
+            if existing is None or rl > existing[0]:
+                _country_risk[cc] = (rl, zone.name)
+        for ap in zone.airports:
+            existing = _airport_risk.get(ap)
+            if existing is None or rl > existing[0]:
+                _airport_risk[ap] = (rl, zone.name)
+
+    return _zones
+
+
+def check_route(airports: list[str]) -> RiskAssessment:
+    load_zones()
+    assert _country_risk is not None and _airport_risk is not None
+
+    worst = RiskLevel.SAFE
+    flagged: list[FlaggedAirport] = []
+
+    for code in airports:
+        # Check specific airport first
+        ap_entry = _airport_risk.get(code)
+        if ap_entry:
+            rl, zone_name = ap_entry
+            country = airport_country(code) or "??"
+            flagged.append(FlaggedAirport(
+                code=code, country=country, zone_name=zone_name, risk_level=rl
+            ))
+            if rl > worst:
+                worst = rl
+            continue
+
+        # Check country
+        country = airport_country(code)
+        if country:
+            cc_entry = _country_risk.get(country)
+            if cc_entry:
+                rl, zone_name = cc_entry
+                flagged.append(FlaggedAirport(
+                    code=code, country=country, zone_name=zone_name, risk_level=rl
+                ))
+                if rl > worst:
+                    worst = rl
+
+    return RiskAssessment(risk_level=worst, flagged_airports=flagged)
+
+
+def zones_age_warning() -> str | None:
+    """Return a warning string if the conflict zone data is stale, else None."""
+    load_zones()
+
+    # Check if using cached version
+    if _CACHE_PATH.exists():
+        age_days = (time.time() - _CACHE_PATH.stat().st_mtime) / 86400
+        if age_days > 7:
+            return f"Conflict zone data is {int(age_days)} days old. Run `opensky zones --update` to refresh."
+        return None
+
+    # Using bundled -- check its age from metadata
+    data = json.loads(_BUNDLED_PATH.read_text())
+    updated = data.get("metadata", {}).get("updated", "")
+    if updated:
+        from datetime import datetime
+        try:
+            updated_dt = datetime.strptime(updated, "%Y-%m-%d")
+            age_days = (datetime.now() - updated_dt).days
+            if age_days > 14:
+                return f"Bundled conflict zone data is {age_days} days old. Run `opensky zones --update` to refresh."
+        except ValueError:
+            pass
+
+    return None
+
+
+def save_cached_zones(data: str) -> None:
+    _CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    _CACHE_PATH.write_text(data)
+    # Force reload
+    global _zones
+    _zones = None

opensky/search.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import logging
+import time
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from opensky import cache
+from opensky.config import ScanConfig
+from opensky.models import FlightLeg, FlightResult, RiskLevel, ScoredFlight
+from opensky.providers import FlightProvider, configured_providers
+from opensky.safety import check_route
+
+log = logging.getLogger(__name__)
+
+
+class _Unset:
+    """Sentinel for distinguishing 'not provided' from None."""
+
+_UNSET = _Unset()
+
+STOPS_INT: dict[str, int | None] = {
+    "any": None,
+    "non_stop": 0,
+    "one_stop_or_fewer": 1,
+    "two_or_fewer_stops": 2,
+}
+
+
+def _deduplicate(results: list[FlightResult]) -> list[FlightResult]:
+    """Deduplicate flights across providers.
+
+    Key = airline+flight_number per leg + departure date.
+    Same flight from two providers: keep the one with the lowest price
+    (prefer priced over unpriced).
+    """
+    best: dict[str, FlightResult] = {}
+    for flight in results:
+        if not flight.legs:
+            continue
+        dep_date = flight.legs[0].departure_time[:10] if flight.legs[0].departure_time else ""
+        key = dep_date + "|" + "|".join(
+            f"{leg.airline}{leg.flight_number}:{leg.departure_airport}-{leg.arrival_airport}"
+            for leg in flight.legs
+        )
+        existing = best.get(key)
+        if existing is None:
+            best[key] = flight
+        else:
+            # Prefer priced over unpriced; then cheapest
+            if existing.price <= 0 and flight.price > 0:
+                best[key] = flight
+            elif flight.price > 0 and (existing.price <= 0 or flight.price < existing.price):
+                best[key] = flight
+    return list(best.values())
+
+
+def _route_string(origin: str, dest: str, legs: list[FlightLeg]) -> str:
+    from opensky.airports import city_name
+
+    airports = [origin]
+    for leg in legs:
+        if leg.departure_airport != airports[-1]:
+            airports.append(leg.departure_airport)
+        airports.append(leg.arrival_airport)
+    # Deduplicate consecutive
+    deduped = [airports[0]]
+    for a in airports[1:]:
+        if a != deduped[-1]:
+            deduped.append(a)
+    return " → ".join(city_name(code) for code in deduped)
+
+
+def _all_airports(legs: list[FlightLeg]) -> list[str]:
+    airports = []
+    for leg in legs:
+        airports.append(leg.departure_airport)
+        airports.append(leg.arrival_airport)
+    return list(dict.fromkeys(airports))
+
+
+class SearchEngine:
+    def __init__(
+        self,
+        currency: str = "EUR",
+        proxy: str | None = None,
+        use_cache: bool = True,
+        seat: str = "economy",
+        stops: str = "any",
+        provider: str | None = None,
+    ):
+        self.currency = currency
+        self.use_cache = use_cache
+        self.seat = seat
+        self.max_stops = STOPS_INT.get(stops, None)
+        self._providers: list[FlightProvider] = configured_providers(
+            currency=currency, proxy=proxy, only=provider,
+        )
+
+    def close(self) -> None:
+        for p in self._providers:
+            try:
+                p.close()
+            except Exception:
+                pass
+        self._providers = []
+
+    def search_one(
+        self,
+        origin: str,
+        dest: str,
+        date: str,
+    ) -> list[FlightResult]:
+        all_results: list[FlightResult] = []
+
+        for provider in self._providers:
+            ck = cache.cache_key(
+                origin, dest, date,
+                seat=self.seat, currency=self.currency,
+                stops=self.max_stops, provider=provider.name,
+            )
+
+            if self.use_cache:
+                cached = cache.get(ck)
+                if cached is not None:
+                    all_results.extend(cached)
+                    continue
+
+            try:
+                results = provider.search(
+                    origin, dest, date,
+                    cabin=self.seat,
+                    currency=self.currency,
+                    max_stops=self.max_stops,
+                )
+            except Exception as e:
+                log.warning("Provider %s failed for %s->%s %s: %s", provider.name, origin, dest, date, e)
+                continue
+
+            if self.use_cache:
+                cache.put(ck, results)
+
+            all_results.extend(results)
+
+        if len(self._providers) > 1:
+            all_results = _deduplicate(all_results)
+
+        return all_results
+
+    def search_scored(
+        self,
+        origin: str,
+        dest: str,
+        date: str,
+        risk_threshold: RiskLevel | None = RiskLevel.HIGH_RISK,
+        price_weight: float = 1.0,
+        duration_weight: float = 0.5,
+        transit_hours: dict[str, float] | None = None,
+        max_price: float = 0,
+    ) -> list[ScoredFlight]:
+        results = self.search_one(origin, dest, date)
+        scored = []
+
+        for flight in results:
+            if max_price > 0 and flight.price > 0 and flight.price > max_price:
+                continue
+
+            airports = _all_airports(flight.legs)
+            risk = check_route(airports)
+
+            # Skip flights at or above the risk threshold
+            if risk_threshold is not None and risk.risk_level >= risk_threshold:
+                continue
+
+            route = _route_string(origin, dest, flight.legs)
+            th = (transit_hours or {}).get(dest, 0.0)
+            total_hours = (flight.duration_minutes / 60) + th
+            price = flight.price if flight.price > 0 else 99999
+            score = (price_weight * price) + (duration_weight * total_hours)
+
+            sf = ScoredFlight(
+                flight=flight,
+                origin=origin,
+                destination=dest,
+                date=date,
+                route=route,
+                risk=risk,
+                score=score,
+                transit_hours=th,
+            )
+            scored.append(sf)
+
+        return scored
+
+    def scan(
+        self,
+        config: ScanConfig,
+        workers: int = 3,
+        delay: float = 1.0,
+        on_progress: Callable[[int, int, int], None] | None = None,
+        on_result: Callable[[ScoredFlight], None] | None = None,
+        risk_threshold_override: RiskLevel | None | _Unset = _UNSET,
+    ) -> list[ScoredFlight]:
+        dates = config.search.date_range.dates()
+        combos = [
+            (o, d, dt)
+            for o in config.search.origins
+            for d in config.search.destinations
+            for dt in dates
+        ]
+        total = len(combos)
+        if risk_threshold_override is not _UNSET:
+            risk_threshold = risk_threshold_override
+        else:
+            risk_threshold = RiskLevel(config.safety.risk_threshold)
+        transit_hours = config.connections.transit_hours
+        pw = config.scoring.price_weight
+        dw = config.scoring.duration_weight
+        mp = config.search.max_price
+
+        all_scored: list[ScoredFlight] = []
+        completed = 0
+        errors = 0
+        consecutive_errors = 0
+        effective_delay = delay
+
+        def _search_combo(combo: tuple[str, str, str]) -> tuple[str, str, str, list[ScoredFlight] | None]:
+            origin, dest, date = combo
+            try:
+                results = self.search_scored(
+                    origin, dest, date,
+                    risk_threshold=risk_threshold,
+                    price_weight=pw,
+                    duration_weight=dw,
+                    transit_hours=transit_hours,
+                    max_price=mp,
+                )
+                return (origin, dest, date, results)
+            except Exception as e:
+                log.warning("Search failed for %s->%s %s: %s", origin, dest, date, e)
+                return (origin, dest, date, None)
+
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            i = 0
+            while i < total:
+                batch = combos[i:i + workers]
+                futures = {executor.submit(_search_combo, c): c for c in batch}
+
+                for future in as_completed(futures):
+                    origin, dest, date, results = future.result()
+                    completed += 1
+
+                    if results is None:
+                        errors += 1
+                        consecutive_errors += 1
+                        if consecutive_errors >= 3:
+                            effective_delay = min(effective_delay * 2, 10.0)
+                            log.warning(
+                                "Increasing delay to %.1fs after %d consecutive errors",
+                                effective_delay, consecutive_errors,
+                            )
+                    else:
+                        if consecutive_errors > 0:
+                            consecutive_errors = 0
+                            effective_delay = max(effective_delay * 0.8, delay)
+                        all_scored.extend(results)
+
+                    if on_progress:
+                        on_progress(completed, total, errors)
+
+                    if results and on_result:
+                        for sf in results:
+                            on_result(sf)
+
+                i += len(batch)
+                if i < total:
+                    time.sleep(effective_delay)
+
+        all_scored.sort(key=lambda x: x.score)
+        return all_scored