const weatherIcons = {
  0: { icon: "sun", label: "Clear sky" },
  1: { icon: "sun", label: "Mainly clear" },
  2: { icon: "cloud-sun", label: "Partly cloudy" },
  3: { icon: "cloud", label: "Overcast" },
  45: { icon: "cloud-fog", label: "Fog" },
  48: { icon: "cloud-fog", label: "Rime fog" },
  51: { icon: "cloud-drizzle", label: "Light drizzle" },
  53: { icon: "cloud-drizzle", label: "Drizzle" },
  55: { icon: "cloud-drizzle", label: "Dense drizzle" },
  56: { icon: "snowflake", label: "Freezing drizzle" },
  57: { icon: "snowflake", label: "Dense freezing drizzle" },
  61: { icon: "cloud-rain", label: "Light rain" },
  63: { icon: "cloud-rain", label: "Rain" },
  65: { icon: "cloud-rain", label: "Heavy rain" },
  66: { icon: "cloud-rain", label: "Freezing rain" },
  67: { icon: "cloud-rain", label: "Heavy freezing rain" },
  71: { icon: "snowflake", label: "Light snow" },
  73: { icon: "snowflake", label: "Snow" },
  75: { icon: "snowflake", label: "Heavy snow" },
  77: { icon: "snowflake", label: "Snow grains" },
  80: { icon: "cloud-rain", label: "Rain showers" },
  81: { icon: "cloud-rain", label: "Moderate showers" },
  82: { icon: "cloud-rain", label: "Violent showers" },
  85: { icon: "snowflake", label: "Snow showers" },
  86: { icon: "snowflake", label: "Heavy snow showers" },
  95: { icon: "cloud-lightning", label: "Thunderstorm" },
  96: { icon: "cloud-lightning", label: "Thunderstorm + hail" },
  99: { icon: "cloud-lightning", label: "Thunderstorm + heavy hail" },
};

function getWeatherIcon(code) {
  return weatherIcons[code] || { icon: "help-circle", label: "Unknown" };
}

def categorize_weather(code: int) -> str:
    """Categorize a WMO weather code into a simple group."""
    if code <= 1:
        return "clear"
    elif code <= 3:
        return "cloudy"
    elif code <= 48:
        return "fog"
    elif code <= 57:
        return "drizzle"
    elif code <= 67:
        return "rain"
    elif code <= 77:
        return "snow"
    elif code <= 86:
        return "showers"
    elif code <= 99:
        return "thunderstorm"
    return "unknown"

# Usage
weather = get_weather("london")
category = categorize_weather(weather["current"]["weather_code"])
print(f"Current conditions: {category}")  # "cloudy"

import requests
import time

class QantoClient:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = "https://api.qanto.com"
        self.session = requests.Session()
        self.session.headers["Authorization"] = f"Bearer {api_key}"

    def get(self, path, params=None, max_retries=3):
        url = f"{self.base_url}{path}"

        for attempt in range(max_retries):
            response = self.session.get(url, params=params)

            # Log rate limit status
            remaining = response.headers.get("X-RateLimit-Remaining")
            limit = response.headers.get("X-RateLimit-Limit")
            if remaining:
                print(f"Rate limit: {remaining}/{limit} remaining")

            if response.status_code == 200:
                return response.json()

            if response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 2))
                print(f"Rate limited! Waiting {retry_after}s...")
                time.sleep(retry_after)
                continue

            if response.status_code >= 500:
                wait = 2 ** attempt
                print(f"Server error. Retrying in {wait}s...")
                time.sleep(wait)
                continue

            response.raise_for_status()

        raise Exception("Max retries exceeded")

# Usage
client = QantoClient("sk_live_YOUR_KEY")
weather = client.get("/v1/weather/london")

class QantoClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = "https://api.qanto.com";
  }

  async get(path, params = {}, maxRetries = 3) {
    const url = new URL(`${this.baseUrl}${path}`);
    Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));

    for (let attempt = 0; attempt < maxRetries; attempt++) {
      const response = await fetch(url, {
        headers: { Authorization: `Bearer ${this.apiKey}` },
      });

      // Log rate limit status
      const remaining = response.headers.get("X-RateLimit-Remaining");
      const limit = response.headers.get("X-RateLimit-Limit");
      if (remaining) console.log(`Rate limit: ${remaining}/${limit}`);

      if (response.ok) return response.json();

      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get("Retry-After") || "2");
        console.log(`Rate limited! Waiting ${retryAfter}s...`);
        await new Promise((r) => setTimeout(r, retryAfter * 1000));
        continue;
      }

      if (response.status >= 500) {
        const wait = Math.pow(2, attempt) * 1000;
        await new Promise((r) => setTimeout(r, wait));
        continue;
      }

      const { error } = await response.json();
      throw new Error(`${response.status}: ${error.message}`);
    }
    throw new Error("Max retries exceeded");
  }
}

// Usage
const client = new QantoClient("sk_live_YOUR_KEY");
const weather = await client.get("/v1/weather/london");