Aviation Jet Fuel Price API

import requests
from datetime import datetime
from typing import Dict, List

class AviationFuelManager:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = 'https://api.oilpriceapi.com/v1'
        self.headers = {'Authorization': f'Token {api_key}'}

    def get_current_jet_fuel_price(self) -> float:
        """Get current jet fuel price per gallon."""
        response = requests.get(
            f'{self.base_url}/prices/latest',
            params={'by_code': 'JET_FUEL_USD'},
            headers=self.headers
        )
        data = response.json()
        return data['data']['price']

    def calculate_flight_fuel_cost(self, distance_nm: float,
                                    aircraft_type: str) -> Dict:
        """Calculate estimated fuel cost for a flight."""
        # Aircraft fuel consumption rates (gallons per nautical mile)
        consumption_rates = {
            'B737': 5.3,      # Boeing 737-800
            'A320': 5.1,      # Airbus A320
            'B777': 11.5,     # Boeing 777-300ER
            'A350': 8.2,      # Airbus A350-900
            'E190': 3.4       # Embraer E190
        }

        consumption_rate = consumption_rates.get(aircraft_type, 5.0)
        fuel_gallons = distance_nm * consumption_rate
        current_price = self.get_current_jet_fuel_price()
        total_cost = fuel_gallons * current_price

        return {
            'distance_nm': distance_nm,
            'aircraft_type': aircraft_type,
            'fuel_gallons': round(fuel_gallons, 0),
            'price_per_gallon': current_price,
            'total_fuel_cost': round(total_cost, 2),
            'cost_per_nm': round(total_cost / distance_nm, 2)
        }

    def calculate_route_economics(self, routes: List[Dict]) -> List[Dict]:
        """Calculate fuel economics for multiple routes."""
        current_price = self.get_current_jet_fuel_price()

        results = []
        for route in routes:
            fuel_gallons = route['distance_nm'] * route['consumption_rate']
            fuel_cost = fuel_gallons * current_price

            results.append({
                'route': f"{route['origin']}-{route['destination']}",
                'distance_nm': route['distance_nm'],
                'fuel_gallons': round(fuel_gallons, 0),
                'fuel_cost': round(fuel_cost, 2),
                'revenue': route.get('revenue', 0),
                'fuel_cost_ratio': round(fuel_cost / route.get('revenue', 1) * 100, 1)
            })

        return sorted(results, key=lambda x: x['fuel_cost_ratio'])

    def get_price_trend(self, days: int = 30) -> Dict:
        """Analyze jet fuel price trend."""
        endpoint = 'past_week' if days <= 7 else 'past_month' if days <= 30 else 'past_year'
        response = requests.get(
            f'{self.base_url}/prices/{endpoint}',
            params={'by_code': 'JET_FUEL_USD', 'interval': '1d'},
            headers=self.headers
        )
        data = response.json()
        prices = [p['price'] for p in data['data']['prices']]

        avg_price = sum(prices) / len(prices)
        current_price = prices[0]
        change_pct = ((current_price - prices[-1]) / prices[-1]) * 100

        return {
            'current_price': current_price,
            'average_price': round(avg_price, 3),
            'min_price': min(prices),
            'max_price': max(prices),
            'price_range': round(max(prices) - min(prices), 3),
            'period_change_pct': round(change_pct, 2),
            'trend': 'rising' if change_pct > 2 else 'falling' if change_pct < -2 else 'stable',
            'volatility': round((max(prices) - min(prices)) / avg_price * 100, 2)
        }

    def calculate_fuel_surcharge(self, base_fuel_price: float,
                                  threshold: float = 0.10) -> Dict:
        """Calculate recommended fuel surcharge based on price movement."""
        current_price = self.get_current_jet_fuel_price()
        price_change = current_price - base_fuel_price
        change_pct = (price_change / base_fuel_price) * 100

        # Determine surcharge recommendation
        if price_change <= 0:
            surcharge = 0
        elif change_pct <= 10:
            surcharge = round(change_pct * 0.5, 1)  # 50% pass-through
        else:
            surcharge = round(5 + (change_pct - 10) * 0.75, 1)  # Higher pass-through above 10%

        return {
            'base_price': base_fuel_price,
            'current_price': current_price,
            'price_change': round(price_change, 3),
            'change_pct': round(change_pct, 2),
            'recommended_surcharge_pct': surcharge,
            'effective_date': datetime.now().strftime('%Y-%m-%d')
        }

# Usage example
fuel_manager = AviationFuelManager('YOUR_API_KEY')

# Calculate flight fuel cost
flight = fuel_manager.calculate_flight_fuel_cost(
    distance_nm=2500,
    aircraft_type='B737'
)
print(f"Flight fuel cost: ${flight['total_fuel_cost']:,.2f}")

# Analyze price trend
trend = fuel_manager.get_price_trend(days=30)
print(f"30-day trend: {trend['trend']} ({trend['period_change_pct']}%)")