vinu

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,18 +1,13 @@
 ---
-title: AI Photo Studio
-emoji: ✨
+title: Face Enhancer Api
+emoji: 📉
 colorFrom: purple
-colorTo: pink
+colorTo: purple
 sdk: gradio
-sdk_version: 5.41.0
+sdk_version: 6.24.0
+python_version: '3.12'
 app_file: app.py
 pinned: false
-license: mit
-short_description: AI face enhancement with CodeFormer
 ---
 
-# ✨ AI Photo Studio
-
-Upload any photo → AI enhances faces → Download PNG
-
-Powered by CodeFormer AI + Professional Post-Processing
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,541 +0,0 @@
-"""
-✨ AI Photo Studio — Works Great With or Without CodeFormer
-Full enhancement pipeline: AI or advanced OpenCV
-"""
-
-import gradio as gr
-import cv2
-import numpy as np
-import time
-import logging
-import tempfile
-import os
-from PIL import Image, ImageEnhance, ImageFilter
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
-logger = logging.getLogger(__name__)
-
-try:
-    import spaces
-except ImportError:
-    class spaces:
-        @staticmethod
-        def GPU(fn=None, **kwargs):
-            if fn is None: return lambda f: f
-            return fn
-
-try:
-    from gradio_client import Client as HFClient
-    # Try to import handle_file, fall back to string path
-    try:
-        from gradio_client import handle_file as _handle_file
-        def make_file_handle(path):
-            return _handle_file(path)
-        logger.info("✅ gradio_client + handle_file available")
-    except ImportError:
-        def make_file_handle(path):
-            return path  # Older gradio_client accepts string paths
-        logger.info("✅ gradio_client available (no handle_file, using string paths)")
-    HAS_CLIENT = True
-except ImportError:
-    HAS_CLIENT = False
-    def make_file_handle(path): return path
-    logger.error("❌ gradio_client not available")
-
-STATE = {'client': None, 'connected': False}
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-
-
-# ═══════════════════════════════════════════════════════════════
-#  CODEFORMER
-# ═══════════════════════════════════════════════════════════════
-
-def connect():
-    if not HAS_CLIENT:
-        logger.error("❌ gradio_client not available")
-        return False
-    try:
-        if HF_TOKEN:
-            logger.info("🔌 Connecting to CodeFormer with HF_TOKEN...")
-            STATE['client'] = HFClient("sczhou/CodeFormer", hf_token=HF_TOKEN)
-        else:
-            logger.info("🔌 Connecting to CodeFormer (no token)...")
-            STATE['client'] = HFClient("sczhou/CodeFormer")
-        STATE['connected'] = True
-        logger.info("✅ Connected to CodeFormer!")
-        return True
-    except Exception as e:
-        logger.error(f"❌ CodeFormer connection failed: {e}")
-        return False
-
-def call_codeformer(pil_img):
-    """Try CodeFormer with multiple parameter combinations"""
-    c = STATE.get('client')
-    if not c: return None
-    
-    configs = [
-        {'upscale': 2, 'fidelity': 0.1},
-        {'upscale': 2, 'fidelity': 0.5},
-        {'upscale': 4, 'fidelity': 0.1},
-    ]
-    
-    for cfg in configs:
-        t = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
-        pil_img.save(t.name, 'PNG')
-        t.close()
-        try:
-            file_arg = make_file_handle(t.name)
-            logger.info(f"Calling CodeFormer: upscale={cfg['upscale']}, fidelity={cfg['fidelity']}, file_type={type(file_arg)}")
-            r = c.predict(
-                image=file_arg,
-                face_align=True,
-                background_enhance=True,
-                face_upsample=True,
-                upscale=cfg['upscale'],
-                codeformer_fidelity=cfg['fidelity'],
-                api_name="/inference"
-            )
-            d = r[0] if isinstance(r, (list, tuple)) else r
-            if isinstance(d, dict): d = d.get('path') or d.get('url')
-            if isinstance(d, str) and os.path.exists(d):
-                logger.info(f"✅ CodeFormer success! Output: {d}")
-                return Image.open(d)
-            elif isinstance(d, str):
-                # Try downloading from URL
-                logger.info(f"CodeFormer returned URL: {d[:100]}")
-                try:
-                    import urllib.request
-                    dl = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
-                    urllib.request.urlretrieve(d, dl.name)
-                    dl.close()
-                    return Image.open(dl.name)
-                except Exception as e2:
-                    logger.warning(f"Download failed: {e2}")
-        except Exception as e:
-            logger.warning(f"CodeFormer failed (upscale={cfg['upscale']}): {e}")
-        finally:
-            try: os.unlink(t.name)
-            except: pass
-    
-    return None
-
-
-# ═══════════════════════════════════════════════════════════════
-#  ADVANCED OPENCV PIPELINE (when CodeFormer unavailable)
-# ═══════════════════════════════════════════════════════════════
-
-def detect_faces(img):
-    h, w = img.shape[:2]
-    ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
-    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
-    m1 = cv2.inRange(ycrcb, np.array([0,133,77]), np.array([255,173,127]))
-    m2 = cv2.inRange(hsv, np.array([0,15,60]), np.array([30,255,255]))
-    skin = cv2.bitwise_and(m1, m2)
-    k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7,7))
-    skin = cv2.morphologyEx(skin, cv2.MORPH_CLOSE, k, iterations=3)
-    skin = cv2.morphologyEx(skin, cv2.MORPH_OPEN, k, iterations=2)
-    n,_,stats,_ = cv2.connectedComponentsWithStats(skin, 8)
-    faces = []
-    for i in range(1, n):
-        a = stats[i, cv2.CC_STAT_AREA]
-        if a > (h*w)*0.005:
-            x,y = stats[i,cv2.CC_STAT_LEFT], stats[i,cv2.CC_STAT_TOP]
-            bw,bh = stats[i,cv2.CC_STAT_WIDTH], stats[i,cv2.CC_STAT_HEIGHT]
-            if 0.4 < bw/max(bh,1) < 2.5:
-                p = int(max(bw,bh)*0.15)
-                faces.append([max(0,x-p), max(0,y-p), min(w,x+bw+p), min(h,y+bh+p)])
-    return faces
-
-def get_skin_mask(img):
-    ycrcb = cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)
-    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
-    m1 = cv2.inRange(ycrcb, np.array([0,133,77]), np.array([255,173,127]))
-    m2 = cv2.inRange(hsv, np.array([0,15,60]), np.array([30,255,255]))
-    kn = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
-    sk = cv2.morphologyEx(cv2.bitwise_and(m1,m2), cv2.MORPH_CLOSE, kn, iterations=2)
-    sk = cv2.morphologyEx(sk, cv2.MORPH_OPEN, kn, iterations=1)
-    return cv2.GaussianBlur(sk, (15,15), 0).astype(np.float32)/255.0
-
-def opencv_full_enhance(img_cv):
-    """Complete OpenCV enhancement pipeline — no AI needed"""
-    h, w = img_cv.shape[:2]
-    r = img_cv.copy()
-
-    # ── 1. Strong denoise ──
-    r = cv2.fastNlMeansDenoisingColored(r, None, 8, 8, 7, 21)
-
-    # ── 2. HDR-like tone mapping ──
-    lab = cv2.cvtColor(r, cv2.COLOR_BGR2LAB)
-    l, a, b = cv2.split(lab)
-    lf = l.astype(np.float32)
-    base = cv2.bilateralFilter(lf, -1, 50, 50)
-    detail = lf - base
-    l_new = np.clip(base * 0.7 + 128 * 0.3 + detail * 1.4, 0, 255).astype(np.uint8)
-    r = cv2.cvtColor(cv2.merge([l_new, a, b]), cv2.COLOR_LAB2BGR)
-
-    # ── 3. CLAHE contrast ──
-    lab = cv2.cvtColor(r, cv2.COLOR_BGR2LAB)
-    l, a, b = cv2.split(lab)
-    l = cv2.createCLAHE(clipLimit=2.5, tileGridSize=(8,8)).apply(l)
-    r = cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR)
-
-    # ── 4. Gamma correction ──
-    gray = cv2.cvtColor(r, cv2.COLOR_BGR2GRAY)
-    mean_b = gray.mean()
-    if mean_b < 115:
-        gamma = 1.0 + (115 - mean_b) / 115 * 0.4
-    elif mean_b > 180:
-        gamma = 1.0 - (mean_b - 180) / 180 * 0.2
-    else:
-        gamma = 1.0
-    if gamma != 1.0:
-        table = np.array([((i/255.0)**(1.0/gamma))*255 for i in range(256)]).astype(np.uint8)
-        r = cv2.LUT(r, table)
-
-    # ── 5. White balance (percentile) ──
-    f = r.astype(np.float32)
-    for c in range(3):
-        lo, hi = np.percentile(f[:,:,c], 1), np.percentile(f[:,:,c], 99)
-        if hi > lo: f[:,:,c] = np.clip((f[:,:,c]-lo)/(hi-lo)*255, 0, 255)
-    r = f.astype(np.uint8)
-
-    # ── 6. Skin smoothing (light) ──
-    sk = get_skin_mask(r)
-    smoothed = cv2.bilateralFilter(r, 7, 25, 25)
-    alpha = np.expand_dims(sk * 0.2, 2)
-    r = np.clip(r.astype(np.float32)*(1-alpha) + smoothed.astype(np.float32)*alpha, 0, 255).astype(np.uint8)
-    # Texture restore
-    detail = r.astype(np.float32) - cv2.GaussianBlur(r, (0,0), 1.5).astype(np.float32)
-    r = np.clip(r.astype(np.float32) + detail * 0.5 * np.expand_dims(sk, 2), 0, 255).astype(np.uint8)
-
-    # ── 7. Face-specific sharpening ──
-    faces = detect_faces(r)
-    if faces:
-        for x1,y1,x2,y2 in faces:
-            face = r[y1:y2, x1:x2].copy()
-            if face.size == 0: continue
-            # Strong unsharp on face
-            g = cv2.GaussianBlur(face, (0,0), 2.0)
-            sharpened = cv2.addWeighted(face, 1.7, g, -0.7, 0)
-            # Detail kernel
-            kernel = np.array([[0,-0.5,0],[-0.5,3.0,-0.5],[0,-0.5,0]])
-            sharpened = cv2.filter2D(sharpened, -1, kernel)
-            # Blend back
-            fh, fw = sharpened.shape[:2]
-            mask = np.ones((fh,fw), dtype=np.float32)
-            border = int(min(fh,fw)*0.15)
-            for i in range(border):
-                al = i/border
-                mask[i,:]*=al; mask[-(i+1),:]*=al; mask[:,i]*=al; mask[:,-(i+1)]*=al
-            mask = cv2.GaussianBlur(mask, (11,11), 0)
-            m3 = np.expand_dims(mask, 2)
-            region = r[y1:y2, x1:x2].astype(np.float32)
-            r[y1:y2, x1:x2] = np.clip(region*(1-m3) + sharpened.astype(np.float32)*m3, 0, 255).astype(np.uint8)
-    else:
-        # No faces — sharpen entire image
-        g = cv2.GaussianBlur(r, (0,0), 2.0)
-        r = cv2.addWeighted(r, 1.5, g, -0.5, 0)
-        kernel = np.array([[0,-0.4,0],[-0.4,2.6,-0.4],[0,-0.4,0]])
-        r = cv2.filter2D(r, -1, kernel)
-
-    # ── 8. Skin tone fix (prevent blue) ──
-    if faces:
-        for x1,y1,x2,y2 in faces:
-            face = r[y1:y2, x1:x2].copy()
-            if face.size == 0: continue
-            sk_face = get_skin_mask(face)
-            sk_bool = sk_face > 0.5
-            if np.sum(sk_bool) < 100: continue
-            avg_b = np.mean(face[:,:,0][sk_bool])
-            avg_r = np.mean(face[:,:,2][sk_bool])
-            if avg_b > avg_r * 0.85:
-                correction = np.ones_like(face, dtype=np.float32)
-                correction[:,:,0] = 0.92
-                correction[:,:,2] = 1.05
-                sk3 = np.expand_dims(sk_face, 2)
-                corrected = face.astype(np.float32)*(1-sk3*0.5) + (face.astype(np.float32)*correction)*sk3*0.5
-                face_fixed = np.clip(corrected, 0, 255).astype(np.uint8)
-                fh, fw = face_fixed.shape[:2]
-                mask = np.ones((fh,fw), dtype=np.float32)
-                border = int(min(fh,fw)*0.12)
-                for i in range(border):
-                    al = i/border
-                    mask[i,:]*=al; mask[-(i+1),:]*=al; mask[:,i]*=al; mask[:,-(i+1)]*=al
-                mask = cv2.GaussianBlur(mask, (9,9), 0)
-                m3 = np.expand_dims(mask, 2)
-                region = r[y1:y2, x1:x2].astype(np.float32)
-                r[y1:y2, x1:x2] = np.clip(region*(1-m3) + face_fixed.astype(np.float32)*m3, 0, 255).astype(np.uint8)
-
-    # ── 9. Warm color grading ──
-    lab = cv2.cvtColor(r, cv2.COLOR_BGR2LAB).astype(np.float32)
-    lab[:,:,1] = np.clip(lab[:,:,1] + 0.5, 0, 255)
-    lab[:,:,2] = np.clip(lab[:,:,2] + 0.3, 0, 255)
-    r = cv2.cvtColor(lab.astype(np.uint8), cv2.COLOR_LAB2BGR)
-
-    # ── 10. Saturation ──
-    hsv = cv2.cvtColor(r, cv2.COLOR_BGR2HSV).astype(np.float32)
-    hsv[:,:,1] = np.clip(hsv[:,:,1] * 1.08, 0, 255)
-    r = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
-
-    # ── 11. Vignette ──
-    Y, X = np.ogrid[:h,:w]
-    dist = np.sqrt(((X-w/2)/(w/2))**2 + ((Y-h/2)/(h/2))**2)
-    vig = np.clip(np.expand_dims(1 - 0.04*(dist**2), 2), 0, 1)
-    r = np.clip(r.astype(np.float32) * vig, 0, 255).astype(np.uint8)
-
-    return r
-
-
-def upscale_smart(img_cv, min_size=1024):
-    """Smart multi-step upscaling"""
-    h, w = img_cv.shape[:2]
-    if max(h, w) >= min_size:
-        return img_cv
-    scale = min_size / max(h, w)
-    # Multi-step for better quality
-    if scale > 2.5:
-        # Step 1: 2x
-        img_cv = cv2.resize(img_cv, (w*2, h*2), interpolation=cv2.INTER_LANCZOS4)
-        remaining = scale / 2.0
-        h, w = img_cv.shape[:2]
-        img_cv = cv2.resize(img_cv, (int(w*remaining), int(h*remaining)), interpolation=cv2.INTER_LANCZOS4)
-    else:
-        img_cv = cv2.resize(img_cv, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_LANCZOS4)
-    # Unsharp mask
-    g = cv2.GaussianBlur(img_cv, (0,0), 2.0)
-    img_cv = cv2.addWeighted(img_cv, 1.5, g, -0.5, 0)
-    img_cv = cv2.fastNlMeansDenoisingColored(img_cv, None, 3, 3, 7, 21)
-    return img_cv
-
-
-def skin_smooth(img):
-    """Light skin smoothing with texture preservation"""
-    h, w = img.shape[:2]
-    if h < 50 or w < 50: return img
-    sk = get_skin_mask(img)
-    smoothed = cv2.bilateralFilter(img, 7, 22, 22)
-    alpha = np.expand_dims(sk * 0.2, 2)
-    result = np.clip(img.astype(np.float32)*(1-alpha) + smoothed.astype(np.float32)*alpha, 0, 255).astype(np.uint8)
-    detail = result.astype(np.float32) - cv2.GaussianBlur(result, (0,0), 1.5).astype(np.float32)
-    result = np.clip(result.astype(np.float32) + detail * 0.5 * np.expand_dims(sk, 2), 0, 255).astype(np.uint8)
-    return result
-
-def face_sharpen(img):
-    """Sharpen face regions"""
-    faces = detect_faces(img)
-    if not faces:
-        g = cv2.GaussianBlur(img, (0,0), 2.0)
-        img = cv2.addWeighted(img, 1.5, g, -0.5, 0)
-        kernel = np.array([[0,-0.4,0],[-0.4,2.6,-0.4],[0,-0.4,0]])
-        return cv2.filter2D(img, -1, kernel)
-    for x1,y1,x2,y2 in faces:
-        face = img[y1:y2, x1:x2].copy()
-        if face.size == 0: continue
-        g = cv2.GaussianBlur(face, (0,0), 2.0)
-        sharpened = cv2.addWeighted(face, 1.6, g, -0.6, 0)
-        kernel = np.array([[0,-0.5,0],[-0.5,3.0,-0.5],[0,-0.5,0]])
-        sharpened = cv2.filter2D(sharpened, -1, kernel)
-        fh, fw = sharpened.shape[:2]
-        mask = np.ones((fh,fw), dtype=np.float32)
-        border = int(min(fh,fw)*0.15)
-        for i in range(border):
-            al = i/border
-            mask[i,:]*=al; mask[-(i+1),:]*=al; mask[:,i]*=al; mask[:,-(i+1)]*=al
-        mask = cv2.GaussianBlur(mask, (11,11), 0)
-        m3 = np.expand_dims(mask, 2)
-        region = img[y1:y2, x1:x2].astype(np.float32)
-        img[y1:y2, x1:x2] = np.clip(region*(1-m3) + sharpened.astype(np.float32)*m3, 0, 255).astype(np.uint8)
-    return img
-
-def studio_grade(img):
-    """Studio color grading"""
-    r = img.copy()
-    h, w = r.shape[:2]
-    f = r.astype(np.float32)
-    for c in range(3):
-        lo, hi = np.percentile(f[:,:,c], 1), np.percentile(f[:,:,c], 99)
-        if hi > lo: f[:,:,c] = np.clip((f[:,:,c]-lo)/(hi-lo)*255, 0, 255)
-    r = f.astype(np.uint8)
-    lab = cv2.cvtColor(r, cv2.COLOR_BGR2LAB)
-    l, a, b = cv2.split(lab)
-    l = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8)).apply(l)
-    r = cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR)
-    lab = cv2.cvtColor(r, cv2.COLOR_BGR2LAB).astype(np.float32)
-    lab[:,:,1] = np.clip(lab[:,:,1] + 0.5, 0, 255)
-    lab[:,:,2] = np.clip(lab[:,:,2] + 0.3, 0, 255)
-    r = cv2.cvtColor(lab.astype(np.uint8), cv2.COLOR_LAB2BGR)
-    hsv = cv2.cvtColor(r, cv2.COLOR_BGR2HSV).astype(np.float32)
-    hsv[:,:,1] = np.clip(hsv[:,:,1] * 1.06, 0, 255)
-    r = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
-    Y, X = np.ogrid[:h,:w]
-    dist = np.sqrt(((X-w/2)/(w/2))**2 + ((Y-h/2)/(h/2))**2)
-    vig = np.clip(np.expand_dims(1 - 0.04*(dist**2), 2), 0, 1)
-    r = np.clip(r.astype(np.float32) * vig, 0, 255).astype(np.uint8)
-    return r
-
-def pil_enhance(pil_img):
-    img = pil_img.copy()
-    img = ImageEnhance.Contrast(img).enhance(1.08)
-    img = ImageEnhance.Color(img).enhance(1.06)
-    img = ImageEnhance.Brightness(img).enhance(1.03)
-    img = ImageEnhance.Sharpness(img).enhance(1.15)
-    img = img.filter(ImageFilter.DETAIL)
-    img = img.filter(ImageFilter.UnsharpMask(radius=1.5, percent=40, threshold=3))
-    return img
-
-def fix_skin_tone(img):
-    faces = detect_faces(img)
-    if not faces: return img
-    for x1,y1,x2,y2 in faces:
-        face = img[y1:y2, x1:x2].copy()
-        if face.size == 0: continue
-        sk = get_skin_mask(face)
-        sk_bool = sk > 0.5
-        if np.sum(sk_bool) < 100: continue
-        avg_b = np.mean(face[:,:,0][sk_bool])
-        avg_r = np.mean(face[:,:,2][sk_bool])
-        if avg_b > avg_r * 0.85:
-            correction = np.ones_like(face, dtype=np.float32)
-            correction[:,:,0] = 0.92; correction[:,:,2] = 1.05
-            sk3 = np.expand_dims(sk, 2)
-            corrected = face.astype(np.float32)*(1-sk3*0.5) + (face.astype(np.float32)*correction)*sk3*0.5
-            face_fixed = np.clip(corrected, 0, 255).astype(np.uint8)
-            fh, fw = face_fixed.shape[:2]
-            mask = np.ones((fh,fw), dtype=np.float32)
-            border = int(min(fh,fw)*0.12)
-            for i in range(border):
-                al = i/border
-                mask[i,:]*=al; mask[-(i+1),:]*=al; mask[:,i]*=al; mask[:,-(i+1)]*=al
-            mask = cv2.GaussianBlur(mask, (9,9), 0)
-            m3 = np.expand_dims(mask, 2)
-            region = img[y1:y2, x1:x2].astype(np.float32)
-            img[y1:y2, x1:x2] = np.clip(region*(1-m3) + face_fixed.astype(np.float32)*m3, 0, 255).astype(np.uint8)
-    return img
-
-
-# ═══════════════════════════════════════════════════════════════
-#  MAIN PIPELINE
-# ═══════════════════════════════════════════════════════════════
-
-# Dummy GPU function to satisfy ZeroGPU requirement (if hardware is ZeroGPU)
-# The actual enhance function runs on CPU - CodeFormer uses REMOTE GPU
-@spaces.GPU(duration=5)
-def _gpu_placeholder():
-    """Dummy function for ZeroGPU compatibility. Does nothing."""
-    return True
-
-# NOTE: The actual enhance function runs on CPU.
-# CodeFormer AI runs on the REMOTE Space's GPU (sczhou/CodeFormer).
-# Set Space hardware to "CPU basic" for unlimited free usage.
-def enhance(image_pil, progress=gr.Progress()):
-    start = time.time()
-    steps = []
-    if image_pil.mode != 'RGB': image_pil = image_pil.convert('RGB')
-    oh, ow = image_pil.size[1], image_pil.size[0]
-
-    try:
-        # Try CodeFormer
-        progress(0.05, desc="🔌 Connecting to AI...")
-        if not STATE.get('connected'): connect()
-
-        progress(0.1, desc="🤖 AI face restoration...")
-        cf_result = None
-        debug_info = f"connected={STATE.get('connected')}, has_client={STATE.get('client') is not None}, has_gradio={HAS_CLIENT}"
-        if STATE.get('connected'):
-            cf_result = call_codeformer(image_pil)
-            if cf_result:
-                debug_info += ", cf=SUCCESS"
-            else:
-                debug_info += ", cf=FAILED"
-        else:
-            debug_info += ", NOT_CONNECTED"
-
-        if cf_result:
-            steps.append("🤖 CodeFormer AI (fidelity=0.1, 4x)")
-            img_cv = cv2.cvtColor(np.array(cf_result), cv2.COLOR_RGB2BGR)
-        else:
-            # ═══ FULL OPENCV PIPELINE ═══
-            steps.append("🔧 Advanced OpenCV pipeline (11 stages)")
-            img_cv = cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR)
-
-            progress(0.2, desc="🔧 Full enhancement...")
-            img_cv = opencv_full_enhance(img_cv)
-            steps.append("  ✓ Denoise + HDR + CLAHE + Gamma + WB")
-            steps.append("  ✓ Skin smooth + Face sharpen + Tone fix")
-            steps.append("  ✓ Color grade + Saturation + Vignette")
-
-        # Upscale if needed
-        progress(0.5, desc="⬆️ Resolution...")
-        img_cv = upscale_smart(img_cv, 1024)
-        rh, rw = img_cv.shape[:2]
-        steps.append(f"⬆️ {rw}×{rh}")
-
-        # Skin smooth (if CodeFormer was used)
-        if cf_result:
-            progress(0.6, desc="✨ Skin...")
-            img_cv = skin_smooth(img_cv)
-            steps.append("✨ Skin smoothing")
-            progress(0.65, desc="🔍 Sharpen...")
-            img_cv = face_sharpen(img_cv)
-            steps.append("🔍 Face sharpen")
-            progress(0.7, desc="🎨 Color...")
-            img_cv = studio_grade(img_cv)
-            steps.append("🎨 Studio color grading")
-            progress(0.75, desc="⚖️ Tone...")
-            img_cv = fix_skin_tone(img_cv)
-            steps.append("⚖️ Skin tone fix")
-
-        # PIL polish
-        progress(0.85, desc="🖼️ Final polish...")
-        result_pil = Image.fromarray(cv2.cvtColor(img_cv, cv2.COLOR_BGR2RGB))
-        result_pil = pil_enhance(result_pil)
-        steps.append("🖼️ PIL polish")
-
-        # Save PNG
-        progress(0.95, desc="💾 Saving...")
-        tmp = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
-        result_pil.save(tmp.name, format='PNG')
-        final = Image.open(tmp.name)
-
-    except Exception as e:
-        logger.error(f"Error: {e}")
-        steps.append(f"⚠️ Error: {str(e)[:60]}")
-        final = image_pil.copy()
-
-    elapsed = (time.time()-start)*1000
-    rw, rh = final.size
-    progress(1.0, desc=f"✅ {elapsed:.0f}ms")
-
-    lines = [f"## ✨ Enhanced in {elapsed:.0f}ms!\n",
-        f"| Before | After |\n|---|---|\n| {ow}×{oh} | **{rw}×{rh}** |\n",
-        f"*Debug: {debug_info}*",
-        "### Pipeline:"]
-    for s in steps: lines.append(f"- {s}")
-    if not cf_result:
-        lines.append("\n> 💡 **Tip:** Add `HF_TOKEN` in Space Settings → Secrets for AI-powered face restoration (even better results)")
-    return final, "\n".join(lines)
-
-
-# ═══════════════════════════════════════════════════════════════
-#  UI
-# ═══════════════════════════════════════════════════════════════
-
-_T = gr.themes.Soft(primary_hue="purple", secondary_hue="pink")
-_CSS = ".hdr{text-align:center;margin-bottom:12px}.hdr h1{background:linear-gradient(135deg,#7c5cfc,#ec4899);-webkit-background-clip:text;-webkit-text-fill-color:transparent;font-size:2.2em;font-weight:800}.hdr p{color:#888}footer{display:none!important}.gradio-container{max-width:900px!important;margin:0 auto!important}"
-
-def build_app():
-    with gr.Blocks(title="✨ AI Photo Studio", theme=_T, css=_CSS) as app:
-        gr.HTML('<div class="hdr"><h1>✨ AI Photo Studio</h1><p>Upload any photo → Get enhanced result → Download PNG</p></div>')
-        with gr.Row():
-            with gr.Column():
-                inp = gr.Image(label="📸 Upload your photo", type="pil", height=420, sources=["upload","clipboard"])
-                btn = gr.Button("✨ Enhance My Photo", variant="primary", size="lg")
-            with gr.Column():
-                out = gr.Image(label="✨ Enhanced Result (PNG)", type="pil", height=420, format="png")
-                st = gr.Markdown("*Upload a photo and click Enhance*")
-        btn.click(fn=enhance, inputs=[inp], outputs=[out, st])
-    return app
-
-if __name__ == "__main__":
-    app = build_app()
-    app.launch(server_name="0.0.0.0", share=False, show_error=True)

packages.txt

@@ -1,5 +0,0 @@
-libgl1
-libglib2.0-0
-libsm6
-libxext6
-libxrender1

requirements.txt

@@ -1,5 +0,0 @@
-rembg>=2.0.50
-onnxruntime>=1.16.0
-opencv-python-headless>=4.8.0
-numpy>=1.24.0
-Pillow>=10.0.0