Initialize modern architecture for 4K Upscaler Space

README.md

@@ -0,0 +1,98 @@
+---
+title: 4K Upscaler Pro
+emoji: ⬆️
+colorFrom: purple
+colorTo: blue
+sdk: gradio
+sdk_version: "4.44.0"
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# ⬆ 4K Upscaler Pro
+
+AI-powered image & video upscaler supporting up to 4K resolution (3840×2160).
+
+## Features
+- 🖼 Image upscaling (PNG, JPG, WEBP)
+- 🎬 Video upscaling (MP4, AVI, MOV)
+- 🤖 Real-ESRGAN AI upscaling (GPU mode) + Lanczos fallback (CPU)
+- 📡 Full REST API for n8n, Zapier, or any automation tool
+- 🎯 Targets: 4K, 2K, 1080p, or 2× original
+
+## Deployment Guide
+
+### Step 1: Create Hugging Face Space
+1. Go to https://huggingface.co/new-space
+2. Name it: `4k-upscaler`
+3. SDK: **Gradio**
+4. Hardware: **CPU Basic** (free) or **T4 GPU** for Real-ESRGAN
+
+### Step 2: Upload Files
+Upload all essential files to your Space:
+- `app.py`
+- `core.py`
+- `requirements.txt`
+- `pyproject.toml`
+- `packages.txt` (adds ffmpeg for video rendering)
+### Step 3: Get Your API URL
+Your API will be live at:
+```
+https://<your-username>-4k-upscaler.hf.space/api/predict
+```
+
+---
+
+## n8n Integration
+
+### Image Upscaling via n8n HTTP Request Node
+
+```
+Method: POST
+URL: https://<your-username>-4k-upscaler.hf.space/api/predict
+Headers:
+  Content-Type: application/json
+  Authorization: Bearer <YOUR_HF_TOKEN>  (only if Space is private)
+
+Body (JSON):
+{
+  "data": [
+    "data:image/png;base64,<BASE64_IMAGE>",
+    "Lanczos (Fast)",
+    "4K (3840×2160)"
+  ]
+}
+```
+
+### n8n Workflow Steps
+1. **Trigger** (e.g., HTTP webhook or file watch)
+2. **Read Binary Data** → convert image to base64
+3. **HTTP Request** → POST to HF Space API
+4. **Extract Result** → `{{ $json.data[0] }}` = base64 upscaled image
+5. **Write File** → save the upscaled image
+
+### Video Upscaling (fn_index: 1)
+```json
+{
+  "fn_index": 1,
+  "data": [
+    "<video_url_or_base64>",
+    "Lanczos (Fast)",
+    "4K (3840×2160)"
+  ]
+}
+```
+
+---
+
+## API Reference
+
+| Parameter | Values |
+|-----------|--------|
+| Method | `Real-ESRGAN (AI)` or `Lanczos (Fast)` |
+| Target | `4K (3840×2160)`, `2K (2560×1440)`, `1080p (1920×1080)`, `2x Original` |
+
+## Hardware Recommendation
+- **CPU (Free):** Lanczos fast upscaling works perfectly
+- **T4 GPU ($0.60/hr):** Enables Real-ESRGAN AI upscaling for dramatically better quality

app.py

@@ -0,0 +1,203 @@
+import gradio as gr
+
+from core import upscale_image, upscale_video
+
+# ─────────────────────────────────────────────
+# Gradio UI
+# ─────────────────────────────────────────────
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&family=Syne:wght@400;700;800&display=swap');
+
+:root {
+    --bg: #0a0a0f;
+    --surface: #111118;
+    --border: #1e1e2e;
+    --accent: #7c3aed;
+    --accent2: #06b6d4;
+    --text: #e2e8f0;
+    --muted: #64748b;
+}
+
+body, .gradio-container {
+    background: var(--bg) !important;
+    font-family: 'Syne', sans-serif !important;
+    color: var(--text) !important;
+}
+
+h1 { 
+    font-size: 2.5rem !important; 
+    font-weight: 800 !important;
+    background: linear-gradient(135deg, #7c3aed, #06b6d4);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    text-align: center;
+    padding: 1rem 0;
+}
+
+.tab-nav button {
+    font-family: 'Space Mono', monospace !important;
+    background: var(--surface) !important;
+    border: 1px solid var(--border) !important;
+    color: var(--muted) !important;
+    padding: 8px 20px !important;
+}
+
+.tab-nav button.selected {
+    background: var(--accent) !important;
+    color: white !important;
+    border-color: var(--accent) !important;
+}
+
+.gr-button-primary {
+    background: linear-gradient(135deg, #7c3aed, #06b6d4) !important;
+    border: none !important;
+    font-family: 'Space Mono', monospace !important;
+    font-weight: 700 !important;
+    letter-spacing: 0.05em !important;
+}
+
+footer { display: none !important; }
+"""
+
+with gr.Blocks(css=CSS, title="4K Upscaler Pro") as demo:
+    gr.Markdown("# ⬆ 4K Upscaler Pro")
+    gr.Markdown(
+        "<p style='text-align:center; color:#64748b; font-family:Space Mono,monospace'>"
+        "AI-powered image & video upscaling • Up to 4K resolution • REST API available"
+        "</p>"
+    )
+
+    with gr.Tabs():
+        # ── IMAGE TAB ──
+        with gr.TabItem("🖼 Image Upscaler"):
+            with gr.Row():
+                with gr.Column():
+                    img_input = gr.Image(type="pil", label="Upload Image")
+                    img_method = gr.Radio(
+                        ["Real-ESRGAN (AI)", "Lanczos (Fast)"],
+                        value="Lanczos (Fast)",
+                        label="Upscaling Method",
+                    )
+                    img_target = gr.Dropdown(
+                        [
+                            "4K (3840×2160)",
+                            "2K (2560×1440)",
+                            "1080p (1920×1080)",
+                            "2x Original",
+                        ],
+                        value="4K (3840×2160)",
+                        label="Target Resolution",
+                    )
+                    img_btn = gr.Button("⬆ Upscale Image", variant="primary")
+                with gr.Column():
+                    img_output = gr.Image(label="Upscaled Image")
+                    img_info = gr.Textbox(label="Info", interactive=False)
+                    img_download = gr.File(label="⬇ Download PNG")
+
+            img_btn.click(
+                upscale_image,
+                inputs=[img_input, img_method, img_target],
+                outputs=[img_output, img_info, img_download],
+            )
+
+        # ── VIDEO TAB ──
+        with gr.TabItem("🎬 Video Upscaler"):
+            with gr.Row():
+                with gr.Column():
+                    vid_input = gr.Video(label="Upload Video")
+                    vid_method = gr.Radio(
+                        ["Real-ESRGAN (AI)", "Lanczos (Fast)"],
+                        value="Lanczos (Fast)",
+                        label="Upscaling Method",
+                    )
+                    vid_target = gr.Dropdown(
+                        [
+                            "4K (3840×2160)",
+                            "2K (2560×1440)",
+                            "1080p (1920×1080)",
+                            "2x Original",
+                        ],
+                        value="4K (3840×2160)",
+                        label="Target Resolution",
+                    )
+                    vid_btn = gr.Button("⬆ Upscale Video", variant="primary")
+                with gr.Column():
+                    vid_output = gr.Video(label="Upscaled Video")
+                    vid_info = gr.Textbox(label="Info", interactive=False)
+
+            vid_btn.click(
+                upscale_video,
+                inputs=[vid_input, vid_method, vid_target],
+                outputs=[vid_output, vid_info],
+            )
+
+        # ── API DOCS TAB ──
+        with gr.TabItem("📡 API Docs"):
+            gr.Markdown("""
+## REST API — Use from n8n, curl, or any HTTP client
+
+Hugging Face Spaces expose a built-in API automatically via the `/api/predict` endpoint.
+
+---
+
+### 🖼 Image Upscaling API
+
+**POST** `https://<your-username>-4k-upscaler.hf.space/api/predict`
+
+```json
+{
+  "data": [
+    "<base64_image_string>",
+    "Lanczos (Fast)",
+    "4K (3840×2160)"
+  ]
+}
+```
+
+**Response:**
+```json
+{
+  "data": [
+    "<base64_upscaled_image>",
+    "✅ Upscaled: 1280×720 → 3840×2160",
+    "<download_url>"
+  ]
+}
+```
+
+---
+
+### 🎬 Video Upscaling API
+
+**POST** `https://<your-username>-4k-upscaler.hf.space/api/predict`
+
+Use fn_index: 1 for video endpoint.
+
+```json
+{
+  "fn_index": 1,
+  "data": [
+    "<video_file_url_or_base64>",
+    "Lanczos (Fast)",
+    "4K (3840×2160)"
+  ]
+}
+```
+
+---
+
+### 🔗 n8n Integration
+
+Use the **HTTP Request** node in n8n:
+- **Method:** POST
+- **URL:** `https://<your-username>-4k-upscaler.hf.space/api/predict`
+- **Body:** JSON with `data` array (see above)
+- **Headers:** `Content-Type: application/json`
+
+For authenticated spaces, add:
+- **Header:** `Authorization: Bearer <your_HF_token>`
+            """)
+
+# Launch
+if __name__ == "__main__":
+    demo.queue(max_size=5).launch()

core.py

@@ -0,0 +1,177 @@
+import tempfile
+from enum import Enum
+
+import cv2
+import numpy as np
+from PIL import Image
+
+try:
+    from basicsr.archs.rrdbnet_arch import RRDBNet
+    from realesrgan import RealESRGANer
+
+    REALESRGAN_AVAILABLE = True
+except ImportError:
+    REALESRGAN_AVAILABLE = False
+
+
+class TargetResolution(str, Enum):
+    FOUR_K = "4K (3840×2160)"
+    TWO_K = "2K (2560×1440)"
+    TEN_EIGHTY = "1080p (1920×1080)"
+    TWO_X = "2x Original"
+
+
+def get_dimensions(orig_w: int, orig_h: int, target: TargetResolution) -> tuple[int, int]:
+    """Calculate target dimensions based on original size and target resolution."""
+    if target == TargetResolution.FOUR_K:
+        max_w, max_h = 3840, 2160
+    elif target == TargetResolution.TWO_K:
+        max_w, max_h = 2560, 1440
+    elif target == TargetResolution.TEN_EIGHTY:
+        max_w, max_h = 1920, 1080
+    else:  # TWO_X
+        return orig_w * 2, orig_h * 2
+
+    scale_w = max_w / orig_w
+    scale_h = max_h / orig_h
+    scale = min(scale_w, scale_h)
+
+    return int(orig_w * scale), int(orig_h * scale)
+
+
+def load_upscaler(scale: int = 4) -> "RealESRGANer | None":
+    if not REALESRGAN_AVAILABLE:
+        return None
+    model = RRDBNet(
+        num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=scale
+    )
+    upscaler = RealESRGANer(
+        scale=scale,
+        model_path=f"https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x{scale}plus.pth",
+        model=model,
+        tile=512,
+        tile_pad=10,
+        pre_pad=0,
+        half=False,  # CPU-safe
+    )
+    return upscaler
+
+
+def opencv_upscale(img_np: np.ndarray, target_w: int, target_h: int) -> np.ndarray:
+    return cv2.resize(img_np, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+
+
+def upscale_image(
+    image: Image.Image | None, method: str, target_str: str
+) -> tuple[Image.Image | None, str, str | None]:
+
+    if image is None:
+        return None, "❌ No image provided.", None
+
+    try:
+        target = TargetResolution(target_str)
+    except ValueError:
+        target = TargetResolution.FOUR_K
+
+    orig_w, orig_h = image.size
+    img_np = np.array(image)
+
+    target_w, target_h = get_dimensions(orig_w, orig_h, target)
+
+    if method == "Real-ESRGAN (AI)" and REALESRGAN_AVAILABLE:
+        try:
+            upscaler = load_upscaler(scale=4)
+            if upscaler:
+                output, _ = upscaler.enhance(img_np, outscale=target_w / orig_w)
+                output = cv2.resize(output, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4)
+            else:
+                output = opencv_upscale(img_np, target_w, target_h)
+                method = "Lanczos (fallback: ESRGAN uninitialized)"
+        except Exception as e:
+            output = opencv_upscale(img_np, target_w, target_h)
+            method = f"Lanczos (fallback: {str(e)[:60]})"
+    else:
+        output = opencv_upscale(img_np, target_w, target_h)
+        method = "Lanczos (Fast)"
+
+    result_img = Image.fromarray(output)
+    info = f"✅ Upscaled: {orig_w}×{orig_h} → {target_w}×{target_h} | Method: {method}"
+
+    with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:
+        result_img.save(tmp.name, format="PNG")
+        tmp_path = tmp.name
+
+    return result_img, info, tmp_path
+
+
+def upscale_video(
+    video_path: str | None, method: str, target_str: str, progress_callback=None
+) -> tuple[str | None, str]:
+
+    if not video_path:
+        return None, "❌ No video provided."
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return None, "❌ Could not open video."
+
+    try:
+        orig_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        orig_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+        try:
+            target = TargetResolution(target_str)
+        except ValueError:
+            target = TargetResolution.FOUR_K
+
+        target_w, target_h = get_dimensions(orig_w, orig_h, target)
+
+        out_path = tempfile.mktemp(suffix=".mp4")
+        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+        writer = cv2.VideoWriter(out_path, fourcc, fps, (target_w, target_h))
+
+        if not writer.isOpened():
+            return None, "❌ Could not create output video writer."
+
+        try:
+            upscaler = None
+            if method == "Real-ESRGAN (AI)" and REALESRGAN_AVAILABLE:
+                try:
+                    upscaler = load_upscaler(scale=4)
+                except Exception:
+                    upscaler = None
+
+            frame_idx = 0
+            while True:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+
+                if upscaler:
+                    try:
+                        out_frame, _ = upscaler.enhance(frame_rgb, outscale=target_w / orig_w)
+                        out_frame = cv2.resize(
+                            out_frame, (target_w, target_h), interpolation=cv2.INTER_LANCZOS4
+                        )
+                    except Exception:
+                        out_frame = opencv_upscale(frame_rgb, target_w, target_h)
+                else:
+                    out_frame = opencv_upscale(frame_rgb, target_w, target_h)
+
+                writer.write(cv2.cvtColor(out_frame, cv2.COLOR_RGB2BGR))
+                frame_idx += 1
+                if total_frames > 0 and progress_callback:
+                    progress_callback(
+                        (frame_idx / total_frames), f"Processing frame {frame_idx}/{total_frames}"
+                    )
+
+            info = f"✅ Video upscaled: {orig_w}×{orig_h} → {target_w}×{target_h} | {total_frames} frames @ {fps:.1f}fps"
+        finally:
+            writer.release()
+    finally:
+        cap.release()
+
+    return out_path, info

packages.txt

@@ -0,0 +1 @@
+ffmpeg

pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "video-image-enhancer"
+version = "0.1.0"
+description = "AI-powered image and video upscaling suite using Real-ESRGAN"
+dependencies = [
+    "gradio>=4.0.0",
+    "opencv-python-headless",
+    "Pillow",
+    "numpy",
+    "torch",
+    "torchvision",
+    "realesrgan",
+    "basicsr",
+]
+requires-python = ">=3.12"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+    "E",   # pycodestyle errors
+    "W",   # pycodestyle warnings
+    "F",   # pyflakes
+    "I",   # isort
+    "C",   # flake8-comprehensions
+    "B",   # flake8-bugbear
+    "UP",  # pyupgrade
+]
+ignore = [
+    "E501", # line too long, handled by ruff format
+]

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=4.0.0
+opencv-python-headless>=4.8.0.76
+Pillow>=10.0.0
+numpy>=1.26.0,<2.0.0
+torch>=2.0.0
+torchvision>=0.15.0
+realesrgan
+basicsr