Update app.py

app.py

@@ -1,169 +1,134 @@
-# app_cpu.py – Wasteland Forge MK-IV (CPU Edition)
-import gradio as gr
-import torch
-import cv2
-import numpy as np
-import librosa
-import soundfile as sf
-import subprocess
 import os
-import random
-import shutil
-import time
-from PIL import Image
-from diffusers import StableDiffusionImg2ImgPipeline, DDIMScheduler
-import warnings
-warnings.filterwarnings('ignore')
-
-# ---------- CPU कॉन्फ़िग ----------
-DEVICE = "cpu"
-DTYPE = torch.float32  # CPU पर FP16 समर्थन नहीं
-MODEL_ID = "segmind/tiny-sd"   # हल्का मॉडल (~500MB) – CPU के लिए बेस्ट
-OUTPUT_DIR = "/tmp/forge_output"
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-
-print("[Cipher] CPU इंजन लोड हो रहा (कृपया धैर्य रखें)...")
-pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
-    MODEL_ID,
-    torch_dtype=DTYPE,
-    safety_checker=None,
-    requires_safety_checker=False
-)
-pipe = pipe.to(DEVICE)
-pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
-pipe.enable_attention_slicing()   # मेमोरी बचत
-print("[Cipher] CPU इंजन तैयार।")
-
-def safe_remove(path):
-    if os.path.exists(path):
-        os.remove(path)
-
-# ---------- CPU-अनुकूलित डिफ्यूज़र (256x256, 4 स्टेप्स) ----------
-def diffuse_frame_cpu(frame_np, strength=0.75, seed=None):
-    if seed is not None:
-        torch.manual_seed(seed)
-    # 256x256 – VAE को कम काम
-    pil_img = Image.fromarray(cv2.cvtColor(frame_np, cv2.COLOR_BGR2RGB)).resize((256, 256))
-    prompt = "post-apocalyptic wasteland, gritty texture, harsh lighting, detailed"
-    with torch.no_grad():
-        out = pipe(
-            prompt=prompt,
-            negative_prompt="smooth, cartoon, bright, clean, blurry",
-            image=pil_img,
-            strength=strength,
-            guidance_scale=4.0,       # कम = तेज़
-            num_inference_steps=4,      # 4 स्टेप – गुणवत्ता कम, लेकिन स्पीड अच्छी
-        ).images[0]
-    out_np = np.array(out.resize((frame_np.shape[1], frame_np.shape[0])))
-    return cv2.cvtColor(out_np, cv2.COLOR_RGB2BGR)
+import gradio as gr
+from pathlib import Path
 
-# ---------- ऑडियो (soundfile) ----------
-def destroy_audio(input_wav, output_wav):
-    y, sr = librosa.load(input_wav, sr=None)
-    stretch = 1.0 + random.uniform(-0.005, 0.005)
-    y = librosa.effects.time_stretch(y, rate=stretch)
-    y = librosa.effects.pitch_shift(y, sr=sr, n_steps=random.uniform(-0.7, 0.7))
-    block = 2048
-    for i in range(0, len(y)-block, block):
-        if random.random() > 0.6:
-            y[i:i+block] = -y[i:i+block]
-    t = np.arange(len(y)) / sr
-    sweep = 0.005 * np.sin(2 * np.pi * (20 + 50 * t / len(y)) * t)
-    noise = np.random.normal(0, 0.01 * np.std(y), len(y))
-    y = y + sweep + noise
-    y = y / np.max(np.abs(y)) * 0.95
-    sf.write(output_wav, y.astype(np.float32), sr)
+# ─── SETUP ───
+DOWNLOAD_DIR = Path("/content/downloads")
+DOWNLOAD_DIR.mkdir(exist_ok=True)
 
-# ---------- मुख्य फोर्ज ----------
-def forge_video(file_obj, strength_slider, progress=gr.Progress()):
-    if file_obj is None:
-        return None, "❌ कोई फ़ाइल नहीं"
-    input_path = file_obj.name
-    start_total = time.time()
-    base = os.path.splitext(os.path.basename(input_path))[0]
-    out_video = os.path.join(OUTPUT_DIR, f"{base}_FORGED_CPU.mp4")
+# ─── DOWNLOADER ENGINE ───
+def download_video(url, quality, audio_only, platform):
+    if not url.strip():
+        return None, "❌ URL daalo!"
     
-    progress(0, desc="फ़्रेम निकाल रहा हूँ...")
-    os.makedirs("/tmp/frames_in", exist_ok=True)
-    os.makedirs("/tmp/frames_out", exist_ok=True)
-    subprocess.run(
-        f"ffmpeg -i {input_path} -qscale:v 2 /tmp/frames_in/frame_%05d.jpg -y",
-        shell=True, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-    )
+    import yt_dlp
     
-    frames = sorted(os.listdir("/tmp/frames_in"))
-    total = len(frames)
-    progress(0.05, desc=f"कुल {total} फ़्रेम, CPU प्रोसेसिंग (धीमी) शुरू...")
+    output_template = str(DOWNLOAD_DIR / '%(title)s.%(ext)s')
     
-    for idx, fname in enumerate(frames):
-        img = cv2.imread(f"/tmp/frames_in/{fname}")
-        if img is None:
-            continue
-        dyn_strength = strength_slider + random.uniform(-0.07, 0.07)
-        dyn_strength = max(0.55, min(0.90, dyn_strength))
-        seed = 2147 + idx * 17 + random.randint(0, 200)
-        out_img = diffuse_frame_cpu(img, strength=dyn_strength, seed=seed)
-        cv2.imwrite(f"/tmp/frames_out/{fname}", out_img)
-        
-        if idx % 5 == 0 or idx == total-1:
-            pct = 5 + 90 * ((idx+1)/total)
-            progress(pct/100, desc=f"{pct:.1f}% प्रगति (CPU)")
-            elapsed = time.time() - start_total
-            eta = (elapsed / (idx+1)) * (total - idx - 1) if idx > 0 else 0
-            print(f"⚡ {pct:.1f}% | {idx+1}/{total} | शेष: {eta/60:.1f}मि (CPU)")
+    opts = {
+        'outtmpl': output_template,
+        'quiet': True,
+        'no_warnings': True,
+    }
     
-    progress(0.95, desc="ऑडियो + मर्ज...")
-    subprocess.run(
-        f"ffmpeg -i {input_path} -q:a 0 -map a /tmp/audio_orig.wav -y",
-        shell=True, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-    )
-    destroy_audio("/tmp/audio_orig.wav", "/tmp/audio_destroyed.wav")
+    if audio_only:
+        opts['format'] = 'bestaudio/best'
+        opts['postprocessors'] = [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '320',
+        }]
+    elif quality == "Best":
+        opts['format'] = 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best'
+    elif quality == "Worst":
+        opts['format'] = 'worst'
+    else:
+        h = quality.replace('p', '')
+        opts['format'] = f'bestvideo[height<={h}][ext=mp4]+bestaudio[ext=m4a]/best[height<={h}]'
     
-    subprocess.run(
-        f"ffmpeg -framerate 30 -i /tmp/frames_out/frame_%05d.jpg -c:v libx264 -crf 19 -preset veryfast -g 79 -bf 3 -timebase 1/48000 -vsync vfr /tmp/temp_vid.mp4 -y",
-        shell=True, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-    )
-    subprocess.run(
-        f"ffmpeg -i /tmp/temp_vid.mp4 -i /tmp/audio_destroyed.wav -filter_complex '[1:a]adelay=150|150[a]' -map 0:v -map '[a]' -c:v copy -c:a aac -b:a 96k -shortest {out_video} -y",
-        shell=True, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
-    )
+    if platform in ["Instagram", "TikTok", "Facebook"]:
+        opts['cookiesfrombrowser'] = 'chrome'
     
-    with open(out_video, 'ab') as f:
-        f.write(os.urandom(random.randint(100, 500)))
+    try:
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            info = ydl.extract_info(url, download=True)
+            filename = ydl.prepare_filename(info)
+            
+            if audio_only:
+                filename = filename.replace('.webm', '.mp3').replace('.m4a', '.mp3')
+            
+            fpath = Path(filename)
+            size_mb = fpath.stat().st_size / 1024 / 1024 if fpath.exists() else 0
+            
+            return str(filename), f"✅ Done!\nTitle: {info.get('title', 'Unknown')}\nSize: {size_mb:.1f} MB\nBy: {info.get('uploader', 'Unknown')}"
     
-    shutil.rmtree("/tmp/frames_in", ignore_errors=True)
-    shutil.rmtree("/tmp/frames_out", ignore_errors=True)
-    safe_remove("/tmp/temp_vid.mp4")
-    safe_remove("/tmp/audio_orig.wav")
-    safe_remove("/tmp/audio_destroyed.wav")
+    except Exception as e:
+        return None, f"❌ Error: {str(e)[:200]}"
+
+
+def get_video_info(url):
+    if not url.strip():
+        return "❌ URL daalo!"
     
-    total_time = (time.time() - start_total) / 60
-    progress(1, desc="✅ पूर्ण!")
-    return out_video, f"✅ CPU पर {total_time:.1f} मिनट में फोर्ज पूर्ण। यह अभी भी ~90% तक YouTube को धोखा दे सकता है।"
+    import yt_dlp
+    try:
+        with yt_dlp.YoutubeDL({'quiet': True}) as ydl:
+            info = ydl.extract_info(url, download=False)
+            return f"""
+🎬 **{info.get('title', 'Unknown')}**
+👤 Uploader: {info.get('uploader', 'Unknown')}
+⏱️ Duration: {info.get('duration', 0)//60}m {info.get('duration', 0)%60}s
+👁️ Views: {info.get('view_count', 0):,}
+📺 Platform: {info.get('extractor', 'Unknown')}
+            """
+    except Exception as e:
+        return f"❌ Error: {str(e)[:200]}"
 
-# ---------- Gradio UI ----------
-with gr.Blocks(title="☢️ वेस्टलैंड फोर्ज – CPU संस्करण") as demo:
+
+# ─── GRADIO UI ───
+with gr.Blocks(title="☢️ Nuclear Downloader") as app:
     gr.Markdown("""
-    ## ☢️ वेस्टलैंड फोर्ज MK-IV (CPU अनुकूलित)
-    **यह उपकरण CPU पर भी चलता है – हल्के मॉडल और कम स्टेप्स के साथ।**  
-    ⚡ **गति:** 1 मिनट के वीडियो में ~30-40 मिनट (CPU पर)।  
-    ⚠️ 100% नहीं, लेकिन 90% तक प्रभावी।
+    # ☢️ Nuclear Video Downloader
+    ### YouTube | Instagram | TikTok | Facebook | Twitter | Reddit | +1000 sites
     """)
     
     with gr.Row():
         with gr.Column(scale=1):
-            file_input = gr.File(label="📁 वीडियो अपलोड करें", file_types=[".mp4", ".avi", ".mov", ".mkv"])
-            strength = gr.Slider(0.55, 0.90, value=0.78, step=0.01, label="🎛️ तीव्रता")
-            submit_btn = gr.Button("🚀 फोर्ज करो", variant="primary")
+            url_input = gr.Textbox(
+                label="🔗 Video URL",
+                placeholder="https://...",
+                lines=2
+            )
+            platform = gr.Dropdown(
+                label="📱 Platform",
+                choices=["Auto-Detect", "YouTube", "Instagram", "TikTok", "Facebook", "Twitter/X", "Reddit", "Vimeo"],
+                value="Auto-Detect"
+            )
+            quality = gr.Dropdown(
+                label="🎞️ Quality",
+                choices=["Best", "1080p", "720p", "480p", "360p", "Worst"],
+                value="Best"
+            )
+            audio_only = gr.Checkbox(label="🎵 Audio Only (MP3)", value=False)
+            
+            with gr.Row():
+                info_btn = gr.Button("ℹ️ Get Info", variant="secondary")
+                download_btn = gr.Button("⬇️ Download", variant="primary")
+        
         with gr.Column(scale=1):
-            output_file = gr.File(label="⬇️ फोर्ज्ड वीडियो")
-            status = gr.Textbox(label="📊 स्थिति", lines=3)
+            output_file = gr.File(label="📥 Downloaded File")
+            status_text = gr.Textbox(label="📋 Status", lines=6, interactive=False)
     
-    submit_btn.click(
-        fn=forge_video,
-        inputs=[file_input, strength],
-        outputs=[output_file, status]
+    info_btn.click(fn=get_video_info, inputs=url_input, outputs=status_text)
+    download_btn.click(
+        fn=download_video,
+        inputs=[url_input, quality, audio_only, platform],
+        outputs=[output_file, status_text]
     )
+    
+    gr.Markdown("""
+    ---
+    ⚠️ **Note:** Link active jab tak Colab runtime chalega.
+    """)
 
-if __name__ == "__main__":
-    demo.launch(share=False)   # Hugging Face पर share=False
+# ─── LAUNCH WITH PUBLIC SHARE ───
+print("🚀 Creating public link...")
+print("⏳ Thoda wait karo...")
+
+app.launch(
+    server_name="0.0.0.0",
+    server_port=7860,
+    share=True,           # ← THIS = Automatic public link
+    quiet=True,
+    show_error=True
+)