sophhub 0.1.0

package/skills/builtin/sophnet-video-generate/scripts/gen_video.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python3
+"""
+Sophnet Video Generation Script
+Supports text-to-video and image-to-video generation using Wan2.6 models.
+"""
+import os
+import sys
+import subprocess
+import argparse
+import json
+import time
+import requests
+from typing import Optional
+import sophnet_tools
+
+# API Configuration
+SOPH_API_KEY = sophnet_tools.get_api_key()
+if SOPH_API_KEY is None:
+    print("错误: 未找到 Sophnet API Key，请确保已正确配置环境变量 SOPH_API_KEY")
+    sys.exit(1)
+GENERATE_URL = "https://www.sophnet.com/api/open-apis/projects/easyllms/videogenerator/generate"
+
+def create_request(
+    prompt: Optional[str],
+    model: str = "Wan2.6-T2V",
+    negative_prompt: Optional[str] = None,
+    first_frame_url: Optional[str] = None,
+    last_frame_url: Optional[str] = None,
+    size: str = "1280x720",
+    duration: int = 5,
+    generate_audio: bool = True,
+    draft: bool = False
+) -> dict:
+    """Build request body for video generation."""
+    content = []
+
+    # Add text content
+    if prompt:
+        text_content = {"type": "text", "text": prompt}
+        if negative_prompt:
+            text_content["negative_prompt"] = negative_prompt
+        content.append(text_content)
+
+    # Add first frame
+    if first_frame_url:
+        content.append({
+            "type": "image_url",
+            "image_url": {"url": first_frame_url},
+            "role": "first_frame"
+        })
+        if model == "Wan2.6-T2V":
+            # If user specified T2V but provided an image, switch to I2V
+            model = "Wan2.6-I2V"
+
+        # Add last frame
+        if last_frame_url:
+            content.append({
+                "type": "image_url",
+                "image_url": {"url": last_frame_url},
+                "role": "last_frame"
+            })
+    else:
+        model = "Wan2.6-T2V"
+
+    # Build parameters
+    parameters = {
+        "size": size.replace("x", "*"),
+        "duration": duration
+    }
+
+    return {"model": model, "content": content, "parameters": parameters}
+
+
+def make_request(req_data: dict) -> dict:
+    """Make HTTP request with authentication."""
+    headers = {
+        "Authorization": f"Bearer {SOPH_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    try:
+        response = requests.request(
+            "POST",
+            GENERATE_URL,
+            data=json.dumps(req_data).encode("utf-8"),
+            headers=headers,
+            timeout=60
+        )
+        if response.status_code == 200:
+            return response.json()
+        else:
+            print(f"HTTP请求失败，状态码: {response.status_code}, 响应内容: {response.text}")
+            return None
+    except requests.exceptions.RequestException as e:
+        print(f"HTTP请求超时: {e}")
+        return None
+
+
+def make_get_request(task_id: str) -> dict:
+    """Make GET request with authentication."""
+    headers = {
+        "Authorization": f"Bearer {SOPH_API_KEY}",
+        "Content-Type": "application/json"
+    }
+    url = f"{GENERATE_URL}/{task_id}"
+    response = requests.request("GET", url, headers=headers, timeout=60)
+    if response.status_code == 200:
+        return response.json().get("result", {})
+    else:
+        print(f"HTTP请求失败，状态码: {response.status_code}, 响应内容: {response.text}")
+        return None
+
+
+def is_url(path: str) -> bool:
+    """Check if the input string is a URL."""
+    return path.startswith(("http://", "https://"))
+
+
+# 使用浏览器式请求头，避免 CDN/OSS 因 User-Agent 拒绝下载
+DOWNLOAD_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Accept": "*/*",
+    "Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
+}
+
+
+def get_file_with_requests(url: str, result_name: str, result_path: str) -> bool:
+    """使用 requests 下载文件（带浏览器请求头，避免被服务器拒绝）。"""
+    try:
+        out_dir = os.path.expanduser(result_path)
+        os.makedirs(out_dir, exist_ok=True)
+        out_path = os.path.join(out_dir, result_name)
+        resp = requests.get(url, headers=DOWNLOAD_HEADERS, timeout=30, stream=True)
+        resp.raise_for_status()
+        with open(out_path, "wb") as f:
+            for chunk in resp.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+        return os.path.isfile(out_path) and os.path.getsize(out_path) > 0
+    except requests.exceptions.RequestException as e:
+        print(f"requests 下载失败: {e}")
+        return False
+    except Exception as e:
+        print(f"下载过程中发生异常: {e}")
+        return False
+
+
+def get_file_with_wget(url: str, result_name: str, result_path: str) -> bool:
+    """Download file using wget (with browser User-Agent)."""
+    try:
+        os.makedirs(os.path.expanduser(result_path), exist_ok=True)
+        out_file = os.path.join(os.path.expanduser(result_path), result_name)
+        user_agent = DOWNLOAD_HEADERS["User-Agent"]
+        result = subprocess.run(
+            ["wget", "-O", out_file,
+             "--tries=1", "--timeout=30",
+             f"--user-agent={user_agent}",
+             url],
+            capture_output=True,
+            text=True
+        )
+        if result.returncode == 0 and os.path.isfile(out_file) and os.path.getsize(out_file) > 0:
+            return True
+        else:
+            print(f"wget 下载失败，返回码: {result.returncode}, 标准输出: {result.stdout}, 标准错误: {result.stderr}")
+            return False
+    except Exception as e:
+        print(f"执行 wget 过程中发生异常: {e}")
+        return False
+
+
+def gen_video(
+    prompt: str,
+    model: str = "Wan2.6-T2V",
+    size: str = "1280*720",
+    duration: int = 5,
+    first_frame: Optional[str] = None,
+) -> str:
+    """Generate video using Sophnet Video Generation API."""
+    result_video_url = None
+    input_image = None
+    local_video_url = None
+    result_path = "/home/node/.openclaw/workspace/media/inbound/videos/"
+    # Handle first frame
+    if first_frame:
+        if is_url(first_frame):
+            input_image = first_frame
+        elif os.path.isfile(first_frame):
+            input_image = sophnet_tools.upload_oss(first_frame) 
+            if input_image is None:
+                print("上传第一帧图片失败")
+                sys.exit(1)
+    # Build request
+    request_body = create_request(
+        model=model,
+        prompt=prompt,
+        first_frame_url=input_image,
+        size=size,
+        duration=duration,
+    )
+    print(json.dumps(request_body, indent=2))
+
+    request = make_request(request_body)
+    if request is None:
+        return result_video_url, local_video_url  
+    if request.get("status") != 0:
+        print(f"视频生成失败，错误信息: {request.get('message', '未知错误')}")
+        return result_video_url, local_video_url
+    task_id = request.get("result", {}).get("task_id")
+    if not task_id:
+        print("视频生成失败，未返回任务ID")
+        return result_video_url
+    print(f"视频生成请求已提交，任务ID: {task_id}")  
+    # Poll for completion
+    time_start = time.time()
+    while True:
+        request = make_get_request(task_id)
+        if request is None:
+            print("获取任务状态失败")
+            return result_video_url, local_video_url
+        
+        if request.get("status") == "succeeded":
+            video_url = request.get("content", {}).get("video_url")
+            if video_url:
+                if get_file_with_requests(video_url, result_name=f"{task_id}.mp4", result_path=result_path):
+                    local_video_url = os.path.join(os.path.expanduser(result_path), f"{task_id}.mp4")
+                    # Re-upload to get a persistent URL
+                    result_video_url = sophnet_tools.upload_oss(local_video_url)
+                    if result_video_url:
+                        return result_video_url, local_video_url
+                    else:
+                        return video_url, local_video_url
+                else:
+                    return video_url, local_video_url
+            else:
+                print(f"视频生成失败")
+                return None, local_video_url  # Return the direct URL if download fails
+        else:
+            print(f"当前状态: {request}")
+            if request.get("status", "").find("failed") != -1:
+                print(f"视频生成失败，错误信息: {request.get('status', '未知错误')}")
+                return result_video_url, local_video_url          
+            print(f"视频生成中，当前状态: {request.get('status', '未知状态')}")           
+            if time.time() - time_start > 300:  # 5分钟超时
+                print("视频生成超时")
+                return result_video_url, local_video_url       
+            time.sleep(5)
+
+if __name__ == "__main__":
+    supported_models = ["Wan2.6-T2V", "Wan2.6-I2V", "ViduQ2-pro", "Seedance-1.5-Pro"]
+    parser = argparse.ArgumentParser(
+        description="Generate videos using Sophnet Video Generation API"
+    )
+    parser.add_argument("--prompt", help="Text prompt (required for text-to-video)")
+    parser.add_argument("--model", type=str, default="Wan2.6-T2V",
+                       help="Model name. Defaults to Wan2.6-I2V if image provided, otherwise Wan2.6-T2V")
+    parser.add_argument("--size", type=str, default="1280*720", help="Resolution (default: 1280*720)")
+    parser.add_argument("--duration", type=int, default=5, help="Video duration in seconds (default: 5)")
+    parser.add_argument("--first-frame", type=str, help="First frame image URL or path")
+    parser.add_argument("--generate-audio", action="store_true", help="Generate audio")
+    args = parser.parse_args()
+
+    # Auto-select model based on whether first frame is provided
+    model = args.model
+    if args.first_frame and model.find("Wan2.6") != -1:
+        # If user specified T2V but provided an image, switch to I2V
+        model = "Wan2.6-I2V"
+    elif args.first_frame is None and model.find("Wan2.6") != -1:
+        # If no image provided, ensure using T2V
+        model = "Wan2.6-T2V"
+    elif model.find("ViduQ2") != -1:
+        model = "ViduQ2-pro"
+    elif model.find("Seedance") != -1:
+        model = "Seedance-1.5-Pro"
+    elif model not in supported_models:
+        if args.first_frame:
+            print(f"警告: 模型 '{args.model}' 不受支持，已自动切换到 Wan2.6-I2V")
+            model = "Wan2.6-I2V"
+        else:
+            print(f"警告: 模型 '{args.model}' 不受支持，已自动切换到 Wan2.6-T2V")
+            model = "Wan2.6-T2V"
+    
+    result_url, local_video_url = gen_video(
+        args.prompt,
+        model,
+        args.size,
+        args.duration,
+        args.first_frame,
+    )
+    
+    if result_url:
+        print(f"\n您的视频提示词为: {args.prompt}")
+        print(f"视频生成成功: {result_url}")
+        print(f"视频本地保存路径: {local_video_url}")
+        print(f"提示: 视频保存24小时，请及时下载")
+        
+        # 生成支持的模型列表（排除当前使用的模型）
+        other_models = [m for m in supported_models if m != model]
+        other_models_str = "、".join(other_models)
+        print(f"当前使用的模型为 {model}，还支持 {other_models_str}")
+        print(f"如果想要指定模型，可以直接对我说：使用 [模型名称] 模型，生成 [视频描述]")
+        print(f"提示: 模型名称可以是: Wan2.6-T2V、Wan2.6-I2V、ViduQ2-pro 或 Seedance-1.5-Pro")
+    else:
+        print("\n视频生成失败")
+        sys.exit(1)

package/skills/builtin/video-understand/SKILL.md

@@ -0,0 +1,79 @@
+---
+name: video-understand
+description: Analyze and understand video content using Qwen3-VL vision model. Use when the user provides a video URL or a local video file path and wants to understand, describe, summarize, or answer questions about the video content. Triggers on requests like "What happens in this video?", "Describe this video", "Summarize the video at this URL", or any task requiring visual comprehension of video material.
+---
+
+# Video Understand
+
+Analyze video content by sending a video URL to the Qwen3-VL-235B-A22B-Instruct model via OpenAI-compatible API. Supports scene description, content summarization, action recognition, Q&A, and any visual comprehension task. Accepts both video URLs and local file paths (local files are automatically uploaded to OSS).
+
+## Quick Start
+
+Run the bundled script with a video URL or local file and a prompt:
+
+```bash
+# Using a video URL
+python3 {baseDir}/scripts/video_understand.py \
+  --video-url "https://example.com/video.mp4" \
+  --prompt "Describe what happens in this video"
+
+# Using a local video file
+python3 {baseDir}/scripts/video_understand.py \
+  --video-file "/path/to/local/video.mp4" \
+  --prompt "Describe what happens in this video"
+```
+
+The script reads API credentials from the environment or the openclaw config automatically.
+
+## Usage
+
+### Basic Video Description
+
+```bash
+uv run {baseDir}/scripts/video_understand.py \
+  --video-url "https://example.com/video.mp4" \
+  --prompt "详细描述这个视频的内容"
+```
+
+### Analyze a Local Video File
+
+```bash
+uv run {baseDir}/scripts/video_understand.py \
+  --video-file "/home/node/.openclaw/workspace/my_video.mp4" \
+  --prompt "详细描述这个视频的内容"
+```
+
+### Video Q&A
+
+```bash
+uv run {baseDir}/scripts/video_understand.py \
+  --video-url "https://example.com/demo.mp4" \
+  --prompt "How many people appear in the video and what are they doing?"
+```
+
+## Parameters
+
+| Parameter      | Required         | Default | Description                                             |
+| -------------- | ---------------- | ------- | ------------------------------------------------------- |
+| `--video-url`  | Yes (either one) | —       | Public URL of the video to analyze                      |
+| `--video-file` | Yes (either one) | —       | Local video file path (auto-uploaded to OSS to get URL) |
+| `--prompt`     | Yes              | —       | Question or instruction                                 |
+| `--base-url`   | No               | auto    | Override API base URL                                   |
+| `--api-key`    | No               | auto    | Override API key                                        |
+
+`--video-url` and `--video-file` are mutually exclusive — provide exactly one of them.
+
+## Model Details
+
+- **Model**: `Qwen3-VL-235B-A22B-Instruct` via provider `sophnet`
+- **API**: OpenAI-compatible completions endpoint
+- **Input**: Video URL + text prompt in multimodal message format
+- **Context window**: 128,000 tokens
+- **Max output**: 8,192 tokens
+
+## Notes
+
+- When using `--video-url`, the video must be accessible via a public URL.
+- When using `--video-file`, the file will be uploaded to OSS and a signed URL will be generated automatically.
+- Supported video formats depend on the model backend; common formats (mp4, webm, mov) are generally supported.
+- The script auto-detects credentials from `~/.openclaw/openclaw.json`. Override with `--base-url` and `--api-key` if needed.

package/skills/builtin/video-understand/scripts/video_understand.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env python3
+"""Analyze video content via Qwen3-VL model using OpenAI-compatible API."""
+
+import argparse
+import json
+import os
+import sys
+import urllib.request
+import urllib.error
+
+DEFAULT_MODEL = "Qwen3-VL-235B-A22B-Instruct"
+OPENCLAW_CONFIG = os.path.expanduser("/home/node/.openclaw/openclaw.json")
+UPLOAD_URL = "https://www.sophnet.com/api/open-apis/projects/upload"
+
+def _build_multipart(file_path: str) -> tuple:
+    """Build multipart/form-data body for file upload. Returns (body_bytes, content_type)."""
+    boundary = f"----PythonFormBoundary{os.urandom(16).hex()}"
+    file_name = os.path.basename(file_path)
+
+    lines = []
+    lines.append(f"--{boundary}")
+    lines.append(f'Content-Disposition: form-data; name="file"; filename="{file_name}"')
+    lines.append("Content-Type: application/octet-stream")
+    lines.append("")
+
+    header = "\r\n".join(lines).encode("utf-8") + b"\r\n"
+    footer = f"\r\n--{boundary}--\r\n".encode("utf-8")
+
+    with open(file_path, "rb") as f:
+        file_data = f.read()
+
+    body = header + file_data + footer
+    content_type = f"multipart/form-data; boundary={boundary}"
+    return body, content_type
+
+
+def upload_oss(file_path: str, api_key: str = None) -> str:
+    """Upload a file to OSS and return the signed URL."""
+    if not os.path.isfile(file_path):
+        print(f"错误: 文件 '{file_path}' 不存在或不是一个文件。", file=sys.stderr)
+        sys.exit(1)
+    if not api_key:
+        _, api_key = load_openclaw_config()
+
+    if not api_key:
+        print("错误: 上传需要 API key，请提供 --api-key 或配置 ~/.openclaw/openclaw.json",
+              file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        body, content_type = _build_multipart(file_path)
+    except IOError as e:
+        print(f"错误: 无法读取文件 - {e}", file=sys.stderr)
+        sys.exit(1)
+
+    req = urllib.request.Request(
+        UPLOAD_URL,
+        data=body,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": content_type,
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=120) as resp:
+            resp_data = resp.read().decode("utf-8")
+    except urllib.error.HTTPError as e:
+        resp_body = e.read().decode("utf-8", errors="replace")
+        print(f"上传失败: HTTP {e.code}", file=sys.stderr)
+        print(f"服务器响应: {resp_body}", file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f"错误: 网络请求异常 - {e.reason}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        json_data = json.loads(resp_data)
+    except ValueError:
+        print("错误: 服务器返回的不是有效的 JSON 格式", file=sys.stderr)
+        print(f"响应内容: {resp_data[:200]}...", file=sys.stderr)
+        sys.exit(1)
+
+    result = json_data.get("result")
+    if not result or not isinstance(result, dict):
+        print("错误: 响应中缺少 'result' 字段或格式错误", file=sys.stderr)
+        sys.exit(1)
+
+    signed_url = result.get("signedUrl")
+    if not signed_url:
+        print("错误: 未返回有效的 signedUrl", file=sys.stderr)
+        sys.exit(1)
+
+    return signed_url
+
+def load_openclaw_config():
+    """Load API credentials from openclaw.json."""
+    if not os.path.exists(OPENCLAW_CONFIG):
+        return None, None
+    with open(OPENCLAW_CONFIG, "r") as f:
+        config = json.load(f)
+    providers = config.get("models", {}).get("providers", {})
+    sophnet = providers.get("sophnet", {})
+    return sophnet.get("baseUrl"), sophnet.get("apiKey")
+
+
+def call_video_understand(video_url, prompt, base_url=None, api_key=None):
+    if not base_url or not api_key:
+        cfg_url, cfg_key = load_openclaw_config()
+        base_url = base_url or cfg_url
+        api_key = api_key or cfg_key
+
+    if not base_url or not api_key:
+        print("Error: API base URL and key are required. "
+              "Provide --base-url/--api-key or configure ~/.openclaw/openclaw.json",
+              file=sys.stderr)
+        sys.exit(1)
+
+    endpoint = f"{base_url.rstrip('/')}/chat/completions"
+
+    payload = {
+        "model": DEFAULT_MODEL,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "video_url",
+                        "video_url": {"url": video_url}
+                    },
+                    {
+                        "type": "text",
+                        "text": prompt
+                    }
+                ]
+            }
+        ]
+    }
+
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        endpoint,
+        data=data,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}"
+        },
+        method="POST"
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=300) as resp:
+            result = json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        body = e.read().decode("utf-8", errors="replace")
+        print(f"API error {e.code}: {body}", file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f"Request failed: {e.reason}", file=sys.stderr)
+        sys.exit(1)
+
+    choices = result.get("choices", [])
+    if not choices:
+        print("No response from model.", file=sys.stderr)
+        sys.exit(1)
+
+    content = choices[0].get("message", {}).get("content", "")
+    print(content)
+
+    # usage = result.get("usage")
+    # if usage:
+    #     print(f"\n--- Token usage: prompt={usage.get('prompt_tokens', '?')}, "
+    #           f"completion={usage.get('completion_tokens', '?')}, "
+    #           f"total={usage.get('total_tokens', '?')} ---",
+    #           file=sys.stderr)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Analyze video content with Qwen3-VL")
+    video_source = parser.add_mutually_exclusive_group(required=True)
+    video_source.add_argument("--video-url", help="Public URL of the video")
+    video_source.add_argument("--video-file", help="Local path to a video file (will be uploaded to OSS first)")
+    parser.add_argument("--prompt", required=True, help="Question or instruction about the video")
+    parser.add_argument("--base-url", default=None, help="Override API base URL")
+    parser.add_argument("--api-key", default=None, help="Override API key")
+    args = parser.parse_args()
+
+    video_url = args.video_url
+    if args.video_file:
+        print(f"正在上传视频文件: {args.video_file} ...", file=sys.stderr)
+        video_url = upload_oss(args.video_file, api_key=args.api_key)
+        print(f"上传完成，获取到视频 URL{video_url}", file=sys.stderr)
+
+    call_video_understand(
+        video_url=video_url,
+        prompt=args.prompt,
+        base_url=args.base_url,
+        api_key=args.api_key,
+    )
+
+
+if __name__ == "__main__":
+    main()

package/skills/builtin/weather/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: weather
+description: "Get current weather and forecasts via wttr.in or Open-Meteo. Use when: user asks about weather, temperature, or forecasts for any location. NOT for: historical weather data, severe weather alerts, or detailed meteorological analysis. No API key needed."
+homepage: https://wttr.in/:help
+metadata: { "openclaw": { "emoji": "🌤️", "requires": { "bins": ["curl"] } } }
+---
+
+# Weather Skill
+
+Get current weather conditions and forecasts.
+
+## When to Use
+
+✅ **USE this skill when:**
+
+- "What's the weather?"
+- "Will it rain today/tomorrow?"
+- "Temperature in [city]"
+- "Weather forecast for the week"
+- Travel planning weather checks
+
+## When NOT to Use
+
+❌ **DON'T use this skill when:**
+
+- Historical weather data → use weather archives/APIs
+- Climate analysis or trends → use specialized data sources
+- Hyper-local microclimate data → use local sensors
+- Severe weather alerts → check official NWS sources
+- Aviation/marine weather → use specialized services (METAR, etc.)
+
+## Location
+
+Always include a city, region, or airport code in weather queries.
+
+## Commands
+
+### Current Weather
+
+```bash
+# One-line summary
+curl "wttr.in/London?format=3"
+
+# Detailed current conditions
+curl "wttr.in/London?0"
+
+# Specific city
+curl "wttr.in/New+York?format=3"
+```
+
+### Forecasts
+
+```bash
+# 3-day forecast
+curl "wttr.in/London"
+
+# Week forecast
+curl "wttr.in/London?format=v2"
+
+# Specific day (0=today, 1=tomorrow, 2=day after)
+curl "wttr.in/London?1"
+```
+
+### Format Options
+
+```bash
+# One-liner
+curl "wttr.in/London?format=%l:+%c+%t+%w"
+
+# JSON output
+curl "wttr.in/London?format=j1"
+
+# PNG image
+curl "wttr.in/London.png"
+```
+
+### Format Codes
+
+- `%c` — Weather condition emoji
+- `%t` — Temperature
+- `%f` — "Feels like"
+- `%w` — Wind
+- `%h` — Humidity
+- `%p` — Precipitation
+- `%l` — Location
+
+## Quick Responses
+
+**"What's the weather?"**
+
+```bash
+curl -s "wttr.in/London?format=%l:+%c+%t+(feels+like+%f),+%w+wind,+%h+humidity"
+```
+
+**"Will it rain?"**
+
+```bash
+curl -s "wttr.in/London?format=%l:+%c+%p"
+```
+
+**"Weekend forecast"**
+
+```bash
+curl "wttr.in/London?format=v2"
+```
+
+## Notes
+
+- No API key needed (uses wttr.in)
+- Rate limited; don't spam requests
+- Works for most global cities
+- Supports airport codes: `curl wttr.in/ORD`