Download frontend/src/lib/hf-inference.js from ilhamdev/rembg: direct link, hf CLI and curl.
- Browser
- Download file 8.68 kB
-
https://huggingface.co/spaces/ilhamdev/rembg/resolve/main/frontend/src/lib/hf-inference.js
- Command line
-
hf download hf://spaces/ilhamdev/rembg/frontend/src/lib/hf-inference.js
-
curl -L -o hf-inference.js https://huggingface.co/spaces/ilhamdev/rembg/resolve/main/frontend/src/lib/hf-inference.js
8.68 kB
| /** | |
| * Hugging Face Gradio ZeroGPU & CPU Fallback Client | |
| * | |
| * Mengelola komunikasi ke Hugging Face Space dengan proteksi kuota: | |
| * 1. Token Pool / Multi-token Rotation (HF_TOKEN / HF_TOKENS) untuk mendistribusikan kuota. | |
| * 2. Header IP Rotation & Forwarding (X-Forwarded-For, CF-Connecting-IP, dsb.) dengan random public IP generator. | |
| * 3. Otomatis Fallback ke endpoint CPU (remove_bg_cpu) jika kuota ZeroGPU Space tercapai. | |
| * 4. Sanitasi pesan error agar ramah pengguna dan tidak menampilkan raw JSON dump. | |
| */ | |
| const PUBLIC_IP_POOLS = [ | |
| '36.68', '36.69', '36.70', '36.71', // Telkom Indonesia | |
| '114.120', '114.121', '114.122', '114.124', // Telkomsel | |
| '180.240', '180.241', '180.250', // Biznet / FirstMedia | |
| '103.10', '103.28', '103.47', // APNIC regional pool | |
| '202.80', '202.152', '202.158', // Indonesian ISPs | |
| '13.212', '13.250', '52.74', // AWS Singapore Edge | |
| '104.28', '172.68', '172.69', // Cloudflare Edge | |
| ] | |
| /** | |
| * Menghasilkan IP publik acak dari pool IP valid non-private. | |
| */ | |
| export function getRandomPublicIp() { | |
| const prefix = PUBLIC_IP_POOLS[Math.floor(Math.random() * PUBLIC_IP_POOLS.length)] | |
| const octet3 = Math.floor(Math.random() * 254) + 1 | |
| const octet4 = Math.floor(Math.random() * 254) + 1 | |
| return `${prefix}.${octet3}.${octet4}` | |
| } | |
| /** | |
| * Memeriksa apakah IP adalah IP internal/private/loopback. | |
| */ | |
| export function isPrivateOrLocalIp(ip) { | |
| if (!ip || typeof ip !== 'string') return true | |
| const trimmed = ip.trim() | |
| return ( | |
| trimmed === '127.0.0.1' || | |
| trimmed === '::1' || | |
| trimmed === 'localhost' || | |
| trimmed.startsWith('10.') || | |
| trimmed.startsWith('192.168.') || | |
| trimmed.startsWith('169.254.') || | |
| /^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(trimmed) | |
| ) | |
| } | |
| /** | |
| * Menyelesaikan IP yang akan dikirim ke backend. | |
| * Jika IP dari request adalah IP eksternal valid, gunakan itu. | |
| * Jika request dari local dev / private IP, gunakan random public IP. | |
| */ | |
| export function resolveForwardedIp(request) { | |
| if (!request || !request.headers) { | |
| return getRandomPublicIp() | |
| } | |
| const rawHeader = | |
| request.headers.get('cf-connecting-ip') || | |
| request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || | |
| request.headers.get('x-real-ip') | |
| if (rawHeader && !isPrivateOrLocalIp(rawHeader)) { | |
| return rawHeader | |
| } | |
| return getRandomPublicIp() | |
| } | |
| /** | |
| * Mengambil token Hugging Face dari environment. | |
| * Mendukung multiple tokens (HF_TOKENS=t1,t2) dengan pemilihan acak untuk meratakan kuota. | |
| */ | |
| export function getHfToken() { | |
| const rawTokens = process.env.HF_TOKENS || process.env.HF_TOKEN || process.env.HUGGINGFACE_TOKEN || process.env.HUGGING_FACE_HUB_TOKEN || '' | |
| const tokenList = rawTokens | |
| .split(',') | |
| .map((t) => t.trim()) | |
| .filter(Boolean) | |
| if (tokenList.length === 0) return '' | |
| if (tokenList.length === 1) return tokenList[0] | |
| // Pick random token dari list untuk load-balancing kuota | |
| return tokenList[Math.floor(Math.random() * tokenList.length)] | |
| } | |
| /** | |
| * Membuat headers lengkap untuk memanggil endpoint Hugging Face Gradio. | |
| */ | |
| export function buildHfHeaders({ token = getHfToken(), clientIp = getRandomPublicIp() } = {}) { | |
| const headers = { | |
| 'Content-Type': 'application/json', | |
| Accept: 'application/json', | |
| 'X-Forwarded-For': clientIp, | |
| 'CF-Connecting-IP': clientIp, | |
| 'X-Real-IP': clientIp, | |
| 'X-Client-IP': clientIp, | |
| 'True-Client-IP': clientIp, | |
| } | |
| if (token) { | |
| headers['Authorization'] = `Bearer ${token}` | |
| } | |
| return headers | |
| } | |
| /** | |
| * Membersihkan pesan error Gradio / SSE menjadi teks ramah pengguna. | |
| */ | |
| export function cleanGradioErrorMessage(rawError) { | |
| if (!rawError) return 'Terjadi kesalahan pada backend AI Hugging Face.' | |
| let msg = typeof rawError === 'string' ? rawError : JSON.stringify(rawError) | |
| try { | |
| const parsed = JSON.parse(msg) | |
| if (parsed.error) { | |
| msg = parsed.title ? `${parsed.title}: ${parsed.error}` : parsed.error | |
| } | |
| } catch { | |
| // msg tetap teks asli jika bukan format JSON | |
| } | |
| if (msg.includes('ZeroGPU runs limit') || msg.includes('ZeroGPU quota exceeded')) { | |
| return 'Batas kuota gratis ZeroGPU Hugging Face sedang tercapai atau antre. Sistem telah mencoba fallback CPU; silakan coba kembali beberapa saat lagi.' | |
| } | |
| return msg | |
| } | |
| /** | |
| * Menjalankan inferensi Gradio SSE dengan toleransi fallback ZeroGPU -> CPU. | |
| */ | |
| export async function executeGradioInference({ | |
| spaceUrl, | |
| dataPayload, | |
| clientIp, | |
| token = getHfToken(), | |
| timeoutMs = 90_000, | |
| }) { | |
| const normalizedSpaceUrl = spaceUrl.replace(/\/+$/, '') | |
| const headers = buildHfHeaders({ token, clientIp }) | |
| // Daftar urutan endpoint: GPU terlebih dahulu, kemudian CPU jika kuota habis | |
| const attempts = [ | |
| { name: 'remove_bg', isGpu: true }, | |
| { name: 'remove_bg_cpu', isGpu: false }, | |
| ] | |
| let lastError = null | |
| for (const attempt of attempts) { | |
| const candidateEndpoints = [ | |
| `${normalizedSpaceUrl}/gradio_api/call/${attempt.name}`, | |
| `${normalizedSpaceUrl}/call/${attempt.name}`, | |
| ] | |
| let callRes = null | |
| let usedEndpoint = '' | |
| let postErrorText = '' | |
| for (const endpoint of candidateEndpoints) { | |
| try { | |
| console.log(`[HF Inference] Memanggil ${endpoint} (${attempt.isGpu ? 'ZeroGPU' : 'CPU Fallback'})...`) | |
| const res = await fetch(endpoint, { | |
| method: 'POST', | |
| headers, | |
| body: JSON.stringify({ data: dataPayload }), | |
| }) | |
| if (res.ok) { | |
| callRes = res | |
| usedEndpoint = endpoint | |
| break | |
| } else { | |
| postErrorText = await res.text() | |
| console.warn(`[HF Endpoint ${res.status}] ${endpoint}:`, postErrorText.slice(0, 120)) | |
| } | |
| } catch (err) { | |
| console.warn(`[HF Fetch Fail] ${endpoint}:`, err.message) | |
| } | |
| } | |
| if (!callRes) { | |
| lastError = new Error( | |
| `Gagal menghubungi backend Hugging Face (${attempt.name}): ${postErrorText.slice(0, 100) || 'Connection failed'}` | |
| ) | |
| // Jika endpoint remove_bg_cpu belum ter-deploy di HuggingFace Space saat ini, lanjutkan | |
| continue | |
| } | |
| let eventId = null | |
| try { | |
| const data = await callRes.json() | |
| eventId = data.event_id | |
| } catch { | |
| // response bukan json | |
| } | |
| if (!eventId) { | |
| lastError = new Error('Hugging Face tidak mengembalikan event_id') | |
| continue | |
| } | |
| // Baca SSE Stream | |
| const sseUrl = `${usedEndpoint}/${eventId}` | |
| const sseController = new AbortController() | |
| const sseTimer = setTimeout(() => sseController.abort(), timeoutMs) | |
| let sseRes = null | |
| try { | |
| sseRes = await fetch(sseUrl, { | |
| headers: { | |
| Accept: 'text/event-stream', | |
| ...(token ? { Authorization: `Bearer ${token}` } : {}), | |
| }, | |
| signal: sseController.signal, | |
| }) | |
| } catch (err) { | |
| lastError = err | |
| continue | |
| } finally { | |
| clearTimeout(sseTimer) | |
| } | |
| if (!sseRes || !sseRes.ok) { | |
| lastError = new Error(`Gagal membaca SSE status dari Hugging Face: ${sseRes?.status || 'unknown'}`) | |
| continue | |
| } | |
| const sseText = await sseRes.text() | |
| const lines = sseText.split('\n') | |
| let currentEvent = '' | |
| let resultOutput = null | |
| let errorMsg = null | |
| for (const line of lines) { | |
| const trimmed = line.trim() | |
| if (trimmed.startsWith('event: ')) { | |
| currentEvent = trimmed.slice(7).trim() | |
| } else if (trimmed.startsWith('data: ')) { | |
| const raw = trimmed.slice(6).trim() | |
| if (currentEvent === 'error') { | |
| errorMsg = raw | |
| break | |
| } | |
| if (currentEvent === 'complete') { | |
| try { | |
| const parsed = JSON.parse(raw) | |
| if (Array.isArray(parsed) && parsed.length > 0) { | |
| resultOutput = parsed[0] | |
| } | |
| } catch { | |
| console.error('[SSE parse error]', raw.slice(0, 100)) | |
| } | |
| } | |
| } | |
| } | |
| // Jika terjadi error kuota ZeroGPU pada attempt GPU, coba attempt berikutnya (CPU Fallback) | |
| if (errorMsg) { | |
| const cleaned = cleanGradioErrorMessage(errorMsg) | |
| if ( | |
| attempt.isGpu && | |
| (errorMsg.includes('ZeroGPU runs limit') || errorMsg.includes('ZeroGPU quota exceeded')) | |
| ) { | |
| console.warn('[HF Inference] ZeroGPU limit terdeteksi, beralih otomatis ke CPU fallback...') | |
| lastError = new Error(cleaned) | |
| continue // Coba attempt berikutnya (remove_bg_cpu) | |
| } | |
| throw new Error(cleaned) | |
| } | |
| if (resultOutput) { | |
| return { | |
| result: resultOutput, | |
| endpointUsed: attempt.name, | |
| isGpu: attempt.isGpu, | |
| } | |
| } | |
| } | |
| throw lastError || new Error('Tidak ada respon berhasil dari backend Hugging Face.') | |
| } | |