Auto-deployed fresh snapshot from GitHub

.gitattributes

@@ -0,0 +1 @@
+*.pb filter=lfs diff=lfs merge=lfs -text

.github/workflows/deploy-hf.yml

@@ -0,0 +1,36 @@
+name: Sync to Hugging Face Space
+
+on:
+  push:
+    branches: 
+      - main
+      - master
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v3
+        with:
+          lfs: true 
+          
+      - name: Push to Hugging Face
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: |
+          # 1. Delete the old history inside the temporary computer
+          rm -rf .git
+          
+          # 2. Start a fresh, clean shipping box
+          git init
+          git lfs install
+          git config user.email "bot@vaniconnect.com"
+          git config user.name "VaniConnect Pipeline Bot"
+          
+          # 3. Pack up the current files (which are now safely configured for LFS)
+          git add .
+          git commit -m "Auto-deployed fresh snapshot from GitHub"
+          
+          # 4. Force overwrite Hugging Face with this clean box
+          git push --force https://vaniconnect:$HF_TOKEN@huggingface.co/spaces/vaniconnect/vaniconnect-api master:main

.gitignore

@@ -0,0 +1,8 @@
+venv/
+.env
+__pycache__/
+firebase_key.json
+downloads/
+vaniconnect.db
+*.mp4
+big-lama.onnx

Dockerfile

@@ -0,0 +1,23 @@
+# 1. Start with a reliable, specific Python server version
+FROM python:3.10-slim-bullseye
+
+# 2. Install the heavy system tools for OpenCV and Video Processing
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsm6 \
+    libxext6 \
+    libgl1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# 3. Set up our working folder
+WORKDIR /app
+
+# 4. Copy our shopping list and install the Python tools
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 5. Copy all our python scripts into the container
+COPY . .
+
+# 6. Turn on the FastAPI engine
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

EDSR_x4.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:dd35ce3cae53ecee2d16045e08a932c3e7242d641bb65cb971d123e06904347f
+size 38573255

FSRCNN_x4.pb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5c68d18db561aed8ead4ffedf1b897ea615baaf60ebf6c35f8e641f8fa4a21bf
+size 41661

README.md

@@ -0,0 +1,10 @@
+---
+title: Vaniconnect Api
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+---
+
+# VaniConnect Studio AI Backend

add_logo.py

@@ -0,0 +1,43 @@
+import cv2
+import os
+from moviepy.editor import VideoFileClip, ImageClip, CompositeVideoClip
+
+def add_user_controlled_logo(video_path, logo_path, output_path, x, y, logo_w, logo_h):
+    if not os.path.exists(video_path) or not os.path.exists(logo_path):
+        return False
+
+    try:
+        video = VideoFileClip(video_path)
+        
+        # Calculate proper height to maintain aspect ratio
+        logo_img = cv2.imread(logo_path, cv2.IMREAD_UNCHANGED)
+        if logo_img is None:
+            return False
+            
+        aspect_ratio = logo_img.shape[0] / logo_img.shape[1]
+        actual_height = int(logo_w * aspect_ratio)
+        
+        logo = (ImageClip(logo_path)
+                .set_duration(video.duration)
+                .resize(width=logo_w, height=actual_height)
+                .set_position((x, y))) 
+
+        final_video = CompositeVideoClip([video, logo])
+        
+        final_video.write_videofile(
+            output_path, 
+            codec="libx264", 
+            audio_codec="aac", 
+            preset="ultrafast",
+            threads=4,
+            fps=video.fps,
+            logger=None
+        )
+        
+        video.close()
+        final_video.close()
+        return True
+        
+    except Exception as e:
+        print(f"Python Error: {e}")
+        return False

app.py

@@ -0,0 +1,781 @@
+import os
+import json
+import cv2
+import boto3
+import shutil
+import razorpay
+from fastapi import FastAPI, Request, BackgroundTasks, UploadFile, File, Form, HTTPException, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+from pydantic import BaseModel
+from dotenv import load_dotenv
+from typing import Optional
+from fastapi import Response
+import firebase_admin
+from firebase_admin import credentials, firestore
+
+# 🤖 YOUR AI TOOLS
+
+import main_photo 
+import main_video
+import bg_remove
+import add_logo
+import enhance_photo
+import enhance_video
+import auto_detect 
+import db
+
+# 1️⃣ LOAD SECRETS FIRST
+load_dotenv()
+
+# 2️⃣ INITIALIZE THE APP (ONLY ONCE!)
+app = FastAPI(title="VaniConnect AI Engine")
+
+# 3️⃣ OPEN THE SECURITY GATES (CORS) - THIS FIXES YOUR BUTTON!
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:5173",
+        "https://vaniconnect-studio.vercel.app",
+        "https://clipeto.com", 
+        "https://www.clipeto.com"
+        
+    ],
+    allow_credentials=True,
+    allow_methods=["*"], 
+    allow_headers=["*"],
+)
+
+# 4️⃣ SET UP RATE LIMITER
+limiter = Limiter(key_func=get_remote_address)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+
+# 5️⃣ SET UP DOWNLOADS FOLDER
+# 1. Define the custom class FIRST so Python knows what it is
+class CORStaticFiles(StaticFiles):
+    async def item_response(self, *args, **kwargs) -> Response:
+        response = await super().item_response(*args, **kwargs)
+        response.headers["Access-Control-Allow-Origin"] = "*"
+        response.headers["Access-Control-Allow-Methods"] = "GET, OPTIONS"
+        response.headers["Access-Control-Allow-Headers"] = "*"
+        return response
+
+# 2. Make the directory physical structure
+os.makedirs("downloads", exist_ok=True)
+
+# 3. Mount the folder using your class LAST
+app.mount("/downloads", CORStaticFiles(directory="downloads"), name="downloads")
+
+# 6️⃣ CONNECT TO CLOUDFLARE R2
+r2_access_key = os.getenv('R2_ACCESS_KEY_ID')
+r2_secret_key = os.getenv('R2_SECRET_ACCESS_KEY')
+r2_endpoint = os.getenv('R2_ENDPOINT_URL')
+bucket_name = os.getenv('R2_BUCKET_NAME')
+
+s3 = boto3.client(
+    's3',
+    endpoint_url=r2_endpoint,
+    aws_access_key_id=r2_access_key,
+    aws_secret_access_key=r2_secret_key,
+    region_name='auto' 
+)
+
+# 7️⃣ RAZORPAY SETUP
+RAZORPAY_KEY_ID = os.getenv("RAZORPAY_KEY_ID")
+RAZORPAY_KEY_SECRET = os.getenv("RAZORPAY_KEY_SECRET")
+
+rzp_client = razorpay.Client(auth=(RAZORPAY_KEY_ID, RAZORPAY_KEY_SECRET))
+
+class OrderRequest(BaseModel):
+    user_id: str
+
+class VerifyRequest(BaseModel):
+    razorpay_order_id: str
+    razorpay_payment_id: str
+    razorpay_signature: str
+    user_id: str
+
+# 8️⃣ FIREBASE ADMIN SETUP
+firebase_secret = os.environ.get("FIREBASE_KEY")
+cred = credentials.Certificate(json.loads(firebase_secret))
+
+# 🔥 FIX: Check if Firebase is already initialized to prevent reload crashes
+if not firebase_admin._apps:
+    firebase_admin.initialize_app(cred)
+
+firestore_db = firestore.client()
+# ---------------------------------------------------------
+# 🚀 ROUTES
+# ---------------------------------------------------------
+
+@app.head("/")
+@app.get("/")
+def read_root():
+    return {"message": "✅ VaniConnect AI Engine is Live and Running!"}
+
+# 1️⃣ CREATE THE ORDER
+@app.post("/api/create-order")
+async def create_order(req: OrderRequest):
+    try:
+        # ₹299 is 99900 paise in Razorpay
+        order_amount = 29900  
+        
+        razorpay_order = rzp_client.order.create({
+            "amount": order_amount,
+            "currency": "INR",
+            "receipt": f"receipt_{req.user_id}",
+            "payment_capture": "1" # Auto-capture the payment
+        })
+        
+        return {
+            "order_id": razorpay_order['id'],
+            "amount": order_amount,
+            "currency": "INR"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# 2️⃣ VERIFY PAYMENT & UNLOCK PRO IN FIREBASE
+@app.post("/api/verify-payment")
+async def verify_payment(req: VerifyRequest):
+    try:
+        # 1. Razorpay securely checks if the payment is legitimate
+        rzp_client.utility.verify_payment_signature({
+            'razorpay_order_id': req.razorpay_order_id,
+            'razorpay_payment_id': req.razorpay_payment_id,
+            'razorpay_signature': req.razorpay_signature
+        })
+        
+        # 2. 🚨 UNLOCK THE FIREBASE USER
+        try:
+            user_ref = firestore_db.collection('users').document(req.user_id)
+            
+            # 🔥 We use .set() with merge=True so it creates the user if they don't exist yet!
+            user_ref.set({"isProUser": True}, merge=True)
+            
+            print(f"✅ Successfully upgraded user {req.user_id} to PRO in Firestore!")
+        except Exception as e:
+            print(f"🔥 FIREBASE ERROR: {e}")
+            # We just print the error to the terminal, but we don't crash the app
+            # because the Razorpay payment was actually successful!
+        
+        return {"status": "success", "message": "Payment verified. Pro Unlocked!"}
+    
+    except razorpay.errors.SignatureVerificationError:
+        raise HTTPException(status_code=400, detail="Payment verification failed!")
+# 👇 (Paste the rest of your AI tool routes down here like /api/enhance, etc.) 👇
+@app.get("/")
+def read_root():
+    return {"message": "✅ VaniConnect AI Engine is Live and Running!"}
+
+@app.post("/api/remove-photo-watermark")
+@limiter.limit("5/minute")
+async def process_photo(
+    request: Request,
+    file: UploadFile = File(...), 
+    x: int = Form(0), 
+    y: int = Form(0), 
+    w: int = Form(0), 
+    h: int = Form(0),
+    style: str = Form("Standard AI Inpaint"),
+    mode: str = Form("manual"),
+    user_id: str = Form(...) # 🌟 1. Added the Catching Mitt!
+):
+    # ❌ 2. Deleted the hardcoded admin_user_1!
+    
+    user_data = db.get_or_create_user(user_id)
+
+    # 2. Safety Check: If Firebase returns NOTHING, stop gracefully!
+    if not user_data:
+        print(f"🚨 Blocked: User {user_id} not found in Firebase!")
+        raise HTTPException(status_code=401, detail="User profile not found. Please log in securely.")
+
+    # 3. Use the NEW Firebase vocabulary
+    is_pro = user_data.get("isProUser", False)
+    credits_left = user_data.get("free_credits", 0)
+
+    # 4. The Paywall Logic
+    if not is_pro and credits_left <= 0:
+        print(f"🚨 Blocked: User {user_id} is out of credits!")
+        raise HTTPException(status_code=402, detail="PaywallTrigger: Daily limit reached. Upgrade to Pro.")
+    
+    input_filename = f"downloads/temp_{file.filename}"
+    output_filename = f"downloads/clean_{file.filename}"
+    
+    with open(input_filename, "wb") as buffer:
+        buffer.write(await file.read())
+
+    print(f"✂️ Removing photo watermark from {input_filename} in {mode.upper()} mode...")
+    
+    # 🌟 THE AI AUTO LOGIC FOR PHOTOS!
+    if mode == "auto":
+        print("🤖 Handing photo to EasyOCR to find the watermark...")
+        box = auto_detect.find_text_watermark(input_filename) 
+        
+        if box:
+            x, y, w, h = box['x'], box['y'], box['w'], box['h']
+            print(f"✅ AI found the text at: x={x}, y={y}, w={w}, h={h}")
+        else:
+            return {"error": "AI Auto could not find clear text in the image. Please use Manual Select."}
+
+    success = main_photo.remove_photo_watermark_web(
+        input_path=input_filename, 
+        output_path=output_filename, 
+        x=x, y=y, w=w, h=h, style=style
+    )
+
+    if not success:
+        return {"error": "Failed to process photo"}
+
+    try:
+        with open(output_filename, 'rb') as clean_file:
+            s3.put_object(
+                Bucket=bucket_name, 
+                Key=f'processed_photos/clean_{file.filename}', 
+                Body=clean_file
+            )
+    except Exception as e:
+        print(f"Cloudflare upload skipped: {e}")
+
+    try:
+        os.remove(input_filename)
+    except Exception as e:
+        print(f"Cleanup issue: {e}")
+
+    # 🌟 3. FIXED INDENTATION: Now credit is deducted safely!
+    if not is_pro:
+        db.deduct_credit(user_id) 
+        print(f"💸 Credit deducted! Remaining: {credits_left - 1}")
+        
+    return {"message": "Success!", "file_name": f"clean_{file.filename}"} 
+
+@app.post("/api/remove-video-watermark")
+@limiter.limit("5/minute")
+async def process_video(
+    request: Request,
+    file: UploadFile = File(...), 
+    x: int = Form(0), 
+    y: int = Form(0), 
+    w: int = Form(0), 
+    h: int = Form(0),
+    mode: str = Form("manual"), 
+    user_id: str = Form(...) 
+):
+    # 1. User Validation & Profile Synchronization
+    user_data = db.get_or_create_user(user_id)
+
+    if not user_data:
+        print(f"🚨 Blocked: User {user_id} not found in Firebase!")
+        raise HTTPException(status_code=401, detail="User profile not found. Please log in securely.")
+
+    is_pro = user_data.get("isProUser", False)
+    credits_left = user_data.get("free_credits", 0)
+
+    if not is_pro and credits_left <= 0:
+        print(f"🚨 Blocked: User {user_id} is out of credits!")
+        raise HTTPException(status_code=402, detail="PaywallTrigger: Daily limit reached. Upgrade to Pro.")
+
+    # 2. Disk Staging Setup
+    input_filename = f"downloads/temp_vid_{file.filename}"
+    output_filename = f"downloads/clean_vid_{file.filename}"
+    
+    with open(input_filename, "wb") as buffer:
+        buffer.write(await file.read())
+
+    print(f"🎬 Incoming Frontend Request Mode: {mode.upper()}")
+    
+    # Both modes will share your amazing fast dominant color patcher engine!
+    backend_execution_mode = "fast" 
+    
+    # 🌟 ISOLATED AUTO MODE LOGIC CORE (Does not interfere with Manual mode parameters)
+    if mode == "auto":
+        print("🤖 Handing video to EasyOCR to parse text layouts...")
+        box = auto_detect.find_text_watermark(input_filename)
+        
+        if box:
+            # Open video metadata stream to calculate strict layout boundaries
+            vid = cv2.VideoCapture(input_filename)
+            vid_w = int(vid.get(cv2.CAP_PROP_FRAME_WIDTH))
+            vid_h = int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            vid.release()
+
+            temp_x, temp_y = box['x'], box['y']
+            temp_w, temp_h = box['w'], box['h']
+            print(f"🎯 Raw AI Detection Coordinates -> x: {temp_x}, y: {temp_y}, w: {temp_w}, h: {temp_h} (Canvas Size: {vid_w}x{vid_h})")
+            
+            # 🛡️ SHIELD 1: Headline Banner Detection (Rejects long horizontal bars)
+            if temp_w > (vid_w * 0.40) or temp_h > (vid_h * 0.30):
+                print("⚠️ Intercepted: AI detected a structural headline banner instead of a corner logo.")
+                try: os.remove(input_filename)
+                except: pass
+                return {"error": "AI Auto targeted the large news headline banner. To keep the banner text intact, please use 'Manual' mode and circle just the corner logo directly!"}
+
+            # 🛡️ SHIELD 2: Central Video Content Guard (Rejects center subtitles/captions)
+            if (vid_h * 0.25) < temp_y < (vid_h * 0.75) and (vid_w * 0.20) < temp_x < (vid_w * 0.80):
+                print("⚠️ Intercepted: AI detected text within the primary central video tracking zone.")
+                try: os.remove(input_filename)
+                except: pass
+                return {"error": "AI Auto detected text elements in the center of the screen. Please switch to 'Manual' mode to specify your watermark area!"}
+
+            # If the coordinates pass both safety filters, assign them smoothly!
+            x, y, w, h = temp_x, temp_y, temp_w, temp_h
+            print(f"✅ Auto coordinates cleared security check: x={x}, y={y}, w={w}, h={h}")
+        else:
+            print("❌ EasyOCR scan returned empty array fields.")
+            try: os.remove(input_filename)
+            except: pass
+            return {"error": "AI Auto could not detect any explicit text watermarks in the corners. Please use Manual Mode to draw your selection box."}
+
+    # 3. Core Engine Execution (Safe, flawless rendering path)
+    success = main_video.remove_watermark_pro(
+        input_path=input_filename, 
+        output_path=output_filename, 
+        x=x, y=y, w=w, h=h,
+        mode=backend_execution_mode
+    )
+
+    if not success:
+        return {"error": "Video processing execution encountered a system error."}
+
+    # 4. Production Cloud Delivery & Cleanup
+    print("☁️ Uploading clean asset matrix to Cloudflare R2...")
+    try:
+        with open(output_filename, 'rb') as clean_file:
+            s3.put_object(
+                Bucket=bucket_name, 
+                Key=f'processed_videos/clean_vid_{file.filename}', 
+                Body=clean_file
+            )
+    except Exception as e:
+        print(f"Cloudflare infrastructure bypass (Local Fallback Triggered): {e}")
+        
+    try:
+        os.remove(input_filename)
+    except Exception as e:
+        print(f"File retention warning: {e}")
+
+    if not is_pro:
+        db.deduct_credit(user_id)
+        
+    return {"message": "Success!", "file_name": f"clean_vid_{file.filename}"}
+
+@app.post("/api/remove-bg")
+@limiter.limit("5/minute")
+async def process_background(
+     request: Request,
+    file: UploadFile = File(...),
+    bg_color: Optional[str] = Form(None),       
+    bg_image: Optional[UploadFile] = File(None) ,
+    user_id: str = Form(...)
+):
+   # 1. Grab the REAL user_id from the frontend (Replace hardcoded string later!)
+   
+    user_data = db.get_or_create_user(user_id)
+
+    # 2. Safety Check: If Firebase returns NOTHING, stop gracefully!
+    if not user_data:
+        print(f"🚨 Blocked: User {user_id} not found in Firebase!")
+        raise HTTPException(status_code=401, detail="User profile not found. Please log in securely.")
+
+    # 3. Use the NEW Firebase vocabulary
+    is_pro = user_data.get("isProUser", False)
+    credits_left = user_data.get("free_credits", 0)
+
+    # 4. The Paywall Logic
+    if not is_pro and credits_left <= 0:
+        print(f"🚨 Blocked: User {user_id} is out of credits!")
+        # 402 Payment Required is the perfect status code here!
+        raise HTTPException(status_code=402, detail="PaywallTrigger: Daily limit reached. Upgrade to Pro.")
+    
+    # --- YOUR EXISTING LOGIC STARTS HERE ---
+    input_filename = f"temp_bg_{file.filename}"
+    base_name = os.path.splitext(file.filename)[0]
+    
+    transparent_filename = f"nobg_{base_name}.png"
+    pro_output_filename = f"pro_bg_{base_name}.jpg"
+    
+    with open(input_filename, "wb") as buffer:
+        buffer.write(await file.read())
+
+    print(f"🧽 Removing background from {input_filename}...")
+    
+    success = bg_remove.remove_background_web(input_path=input_filename, output_path=transparent_filename)
+    if not success:
+        return {"error": "Background removal failed"}
+
+    file_to_upload = transparent_filename
+    content_type = 'image/png'
+
+    if bg_color or bg_image:
+        custom_bg_path = None
+        if bg_image:
+            custom_bg_path = f"temp_custom_bg_{bg_image.filename}"
+            with open(custom_bg_path, "wb") as buffer:
+                buffer.write(await bg_image.read())
+                
+        print("🎨 Applying Pro Background...")
+        pro_success = bg_remove.apply_pro_background(
+            transparent_filename, pro_output_filename, 
+            bg_color_hex=bg_color, bg_image_path=custom_bg_path
+        )
+        if pro_success:
+            file_to_upload = pro_output_filename
+            content_type = 'image/jpeg'
+            
+        if custom_bg_path and os.path.exists(custom_bg_path):
+            os.remove(custom_bg_path)
+
+    shutil.copy(file_to_upload, f"downloads/{file_to_upload}")
+
+    print(f"☁️ Uploading {file_to_upload} to Cloudflare...")
+    with open(file_to_upload, 'rb') as final_file:
+        s3.put_object(
+            Bucket=bucket_name, 
+            Key=f'processed_backgrounds/{file_to_upload}', 
+            Body=final_file,
+            ContentType=content_type 
+        )
+        
+    if os.path.exists(input_filename): os.remove(input_filename)
+    if os.path.exists(transparent_filename): os.remove(transparent_filename)
+    if os.path.exists(pro_output_filename): os.remove(pro_output_filename)
+    
+        
+    # 💰 5. DEDUCT CREDIT: The job was successful, subtract 1 credit!
+    # If they are NOT a pro user, deduct a credit. (Pro users don't lose credits)
+    if not is_pro:
+        db.deduct_credit(user_id)
+        print(f"💸 Credit deducted! Remaining: {credits_left - 1}")
+        
+    return {"message": "Success!", "file_name": file_to_upload}
+
+@app.post("/api/add-custom-logo")
+@limiter.limit("5/minute")
+async def process_add_logo(
+    request: Request,
+    video_file: UploadFile = File(...), 
+    logo_file: UploadFile = File(...), 
+    x: int = Form(...), 
+    y: int = Form(...), 
+    logo_w: int = Form(...), 
+    logo_h: int = Form(100),
+    user_id: str = Form(...) # 🌟 1. Added the Catching Mitt!
+):
+    # ❌ 2. Deleted the hardcoded admin_user_1!
+    
+    user_data = db.get_or_create_user(user_id)
+
+    # 2. Safety Check: If Firebase returns NOTHING, stop gracefully!
+    if not user_data:
+        print(f"🚨 Blocked: User {user_id} not found in Firebase!")
+        raise HTTPException(status_code=401, detail="User profile not found. Please log in securely.")
+
+    # 3. Use the NEW Firebase vocabulary
+    is_pro = user_data.get("isProUser", False)
+    credits_left = user_data.get("free_credits", 0)
+
+    # 4. The Paywall Logic
+    if not is_pro and credits_left <= 0:
+        print(f"🚨 Blocked: User {user_id} is out of credits!")
+        # 402 Payment Required is the perfect status code here!
+        raise HTTPException(status_code=402, detail="PaywallTrigger: Daily limit reached. Upgrade to Pro.")
+
+    # 1. 📂 THE FOLDER FIX: Save everything directly into the 'downloads' folder
+    input_video = f"downloads/temp_vid_{video_file.filename}"
+    input_logo = f"downloads/temp_logo_{logo_file.filename}"
+    output_video = f"downloads/watermarked_{video_file.filename}"
+    
+    # Save both uploaded files directly to the safe folder
+    with open(input_video, "wb") as buffer:
+        buffer.write(await video_file.read())
+        
+    with open(input_logo, "wb") as buffer:
+        buffer.write(await logo_file.read())
+
+    print(f"📌 Stamping logo onto {input_video}...")
+    
+    # 2. Run your logo logic
+    success = add_logo.add_user_controlled_logo(
+        video_path=input_video, 
+        logo_path=input_logo, 
+        output_path=output_video, 
+        x=x, y=y, logo_w=logo_w, logo_h=logo_h
+    )
+
+    if not success:
+        return {"error": "Failed to add logo to video"}
+
+    # 3. THE CLOUD FIX: Wrap in a try/except so local tests don't crash without Wi-Fi
+    print("☁️ Uploading watermarked video to Cloudflare...")
+    try:
+        with open(output_video, 'rb') as clean_file:
+            s3.put_object(
+                Bucket=bucket_name, 
+                Key=f'processed_videos/watermarked_{video_file.filename}', 
+                Body=clean_file
+            )
+    except Exception as e:
+        print(f"Cloudflare upload skipped (Local Mode): {e}")
+        
+    # 4. 🛑 THE DELETE FIX: Clean up inputs, but KEEP the output video!
+    try:
+        os.remove(input_video)
+        os.remove(input_logo)
+        # os.remove(output_video) <-- Commented out so the frontend can play it!
+    except Exception as e:
+        print(f"Cleanup issue: {e}")
+        
+    # Send JUST the final file name back to React
+    if not is_pro:
+        db.deduct_credit(user_id)
+        print(f"💸 Credit deducted! Remaining: {credits_left - 1}")
+
+    return {"message": "Success!", "file_name": f"watermarked_{video_file.filename}"}
+
+@app.post("/api/enhance-photo")
+@limiter.limit("5/minute")
+async def process_enhance_photo(
+    request: Request,
+    file: UploadFile = File(...),
+    factor: int = Form(4), 
+    face_restoration: str = Form("true"), 
+    color_correction: str = Form("false"),
+    user_id: str = Form(...) # 🌟 1. Added the Catching Mitt!
+):
+    # ❌ 2. Deleted the hardcoded admin_user_1!
+    
+    user_data = db.get_or_create_user(user_id)
+
+    # 2. Safety Check: If Firebase returns NOTHING, stop gracefully!
+    if not user_data:
+        print(f"🚨 Blocked: User {user_id} not found in Firebase!")
+        raise HTTPException(status_code=401, detail="User profile not found. Please log in securely.")
+
+    # 3. Use the NEW Firebase vocabulary
+    is_pro = user_data.get("isProUser", False)
+    credits_left = user_data.get("free_credits", 0)
+
+    # 4. The Paywall Logic
+    if not is_pro and credits_left <= 0:
+        print(f"🚨 Blocked: User {user_id} is out of credits!")
+        raise HTTPException(status_code=402, detail="PaywallTrigger: Daily limit reached. Upgrade to Pro.")
+
+    # 1. 📂 THE FOLDER FIX: Save directly into the safe 'downloads' folder
+    input_filename = f"downloads/temp_enhance_{file.filename}"
+    output_filename = f"downloads/enhanced_{file.filename}"
+    
+    # Save uploaded photo locally
+    with open(input_filename, "wb") as buffer:
+        buffer.write(await file.read())
+
+    print(f"✨ Enhancing photo {input_filename} | Factor: {factor}x | Face: {face_restoration} | Color: {color_correction}")
+    
+    # 2. Run your OpenCV enhancement logic
+    # We pass all the React UI settings directly to your engine!
+    success = enhance_photo.enhance_photo_web(
+        input_path=input_filename, 
+        output_path=output_filename, 
+        factor=factor,
+        face_restoration=(face_restoration == "true"),
+        color_correction=(color_correction == "false")
+    )
+
+    if not success:
+        return {"error": "Photo enhancement failed"}
+
+    # 3. ☁️ THE CLOUD FIX: Wrap in try/except so local tests don't crash
+    print("☁️ Uploading enhanced photo to Cloudflare...")
+    try:
+        with open(output_filename, 'rb') as clean_file:
+            s3.put_object(
+                Bucket=bucket_name, 
+                Key=f'processed_enhancements/enhanced_{file.filename}', 
+                Body=clean_file
+            )
+    except Exception as e:
+        print(f"Cloudflare upload skipped (Local Mode): {e}")
+        
+    # 4. 🛑 THE DELETE FIX: Keep the output file alive!
+    try:
+        os.remove(input_filename)
+        # os.remove(output_filename) <-- Commented out so frontend can show it!
+    except Exception as e:
+        print(f"Cleanup issue: {e}")
+        
+    # 5. THE DOUBLE-DOWNLOAD FIX: Send ONLY the file name back to React
+    if not is_pro:
+        db.deduct_credit(user_id)
+        print(f"💸 Credit deducted! Remaining: {credits_left - 1}")
+
+    return {"message": "Success!", "file_name": f"enhanced_{file.filename}"}
+
+@app.post("/api/enhance-video")
+@limiter.limit("5/minute") # <-- 1. The Bouncer: Only 5 downloads per minute!
+async def process_enhance_video(
+    request: Request,
+    file: UploadFile = File(...),
+    # 🛡️ THE SHIELD: Catch the UI settings so React doesn't crash!
+    resolution: str = Form("1080p FHD"), 
+    fps_60: str = Form("true"), 
+    denoise: str = Form("true"),
+    user_id: str = Form(...) # 🌟 1. Added the Catching Mitt!
+):
+    # ❌ 2. Deleted the hardcoded admin_user_1!
+    
+    user_data = db.get_or_create_user(user_id)
+
+    # 2. Safety Check: If Firebase returns NOTHING, stop gracefully!
+    if not user_data:
+        print(f"🚨 Blocked: User {user_id} not found in Firebase!")
+        raise HTTPException(status_code=401, detail="User profile not found. Please log in securely.")
+
+    # 3. Use the NEW Firebase vocabulary
+    is_pro = user_data.get("isProUser", False)
+    credits_left = user_data.get("free_credits", 0)
+
+    # 4. The Paywall Logic
+    if not is_pro and credits_left <= 0:
+        print(f"🚨 Blocked: User {user_id} is out of credits!")
+        raise HTTPException(status_code=402, detail="PaywallTrigger: Daily limit reached. Upgrade to Pro.")
+    
+    # 1. 📂 THE FOLDER FIX: Force the engine to save inside the 'downloads' folder
+    input_filename = f"downloads/temp_enhvid_{file.filename}"
+    output_filename = f"downloads/enhanced_{file.filename}"
+    
+    # Save uploaded video locally
+    with open(input_filename, "wb") as buffer:
+        buffer.write(await file.read())
+
+    print(f"⚡ Enhancing video {input_filename} in Turbo Mode... (UI Settings Caught but using Turbo Override)")
+    
+    # Run your smart MoviePy logic (Turbo Mode)
+    success = enhance_video.enhance_video_smartly(
+        input_path=input_filename, 
+        output_path=output_filename
+    )
+
+    if not success:
+        return {"error": "Video enhancement failed"}
+
+    # Upload the brightened video to Cloudflare
+    print("☁️ Uploading enhanced video to Cloudflare...")
+    try:
+        with open(output_filename, 'rb') as clean_file:
+            s3.put_object(
+                Bucket=bucket_name, 
+                Key=f'processed_videos/enhanced_{file.filename}', 
+                Body=clean_file
+            )
+    except Exception as e:
+        print(f"Cloudflare upload skipped: {e}")
+        
+    # 2. 🛑 THE DELETE FIX: Keep the output file alive!
+    try:
+        os.remove(input_filename) # We can safely delete the temporary input video
+    except Exception:
+        pass
+        
+    # Send JUST the file name back to the website so it knows what to look for
+    if not is_pro:
+        db.deduct_credit(user_id)
+        print(f"💸 Credit deducted! Remaining: {credits_left - 1}")
+        
+    return {"message": "Success!", "file_name": f"enhanced_{file.filename}"}
+
+@app.post("/api/clipcut-pro")
+@limiter.limit("5/minute") # <-- 1. The Bouncer: Only 5 downloads per minute!
+async def process_clipcut(
+    request: Request,
+    file: UploadFile = File(...),
+    start_time: str = Form("00:00:00"), 
+    end_time: str = Form("00:00:10"),   
+    text: str = Form("VaniConnect AI"),
+    user_id: str = Form(...) # 🌟 1. Added the Catching Mitt!
+):
+    # ❌ 2. Deleted the hardcoded admin_user_1!
+    
+    user_data = db.get_or_create_user(user_id)
+
+    # 2. Safety Check: If Firebase returns NOTHING, stop gracefully!
+    if not user_data:
+        print(f"🚨 Blocked: User {user_id} not found in Firebase!")
+        raise HTTPException(status_code=401, detail="User profile not found. Please log in securely.")
+
+    # 3. Use the NEW Firebase vocabulary
+    is_pro = user_data.get("isProUser", False)
+    credits_left = user_data.get("free_credits", 0)
+
+    # 4. The Paywall Logic
+    if not is_pro and credits_left <= 0:
+        print(f"🚨 Blocked: User {user_id} is out of credits!")
+        raise HTTPException(status_code=402, detail="PaywallTrigger: Daily limit reached. Upgrade to Pro.")
+    
+    input_filename = f"downloads/temp_clip_{file.filename}"
+    trimmed_filename = f"downloads/trimmed_{file.filename}"
+    final_filename = f"downloads/final_clipcut_{file.filename}"
+    
+    # 1. Save uploaded video locally
+    with open(input_filename, "wb") as buffer:
+        buffer.write(await file.read())
+
+    print(f"✂️ 1/2: Trimming video from {start_time} to {end_time}...")
+    
+    # 2. Run trimming function (MoviePy understands HH:MM:SS perfectly!)
+    trim_success = trim_video.trim_video(
+        input_path=input_filename, 
+        output_path=trimmed_filename,
+        start_sec=start_time,
+        end_sec=end_time
+    )
+
+    if not trim_success:
+        return {"error": "Video trimming failed. Make sure Start Time is before End Time!"}
+
+    print(f"✍️ 2/2: Adding professional text overlay: '{text}'...")
+
+    # 3. Add text overlay
+    text_success = trim_video.add_professional_text(
+        input_path=trimmed_filename,
+        output_path=final_filename,
+        text=text
+    )
+
+    if not text_success:
+        return {"error": "Text overlay failed"}
+
+    # 4. Upload to Cloudflare (optional cloud step)
+    print("☁️ Uploading ClipCut Pro video to Cloudflare...")
+    try:
+        with open(final_filename, 'rb') as clean_file:
+            s3.put_object(
+                Bucket=bucket_name, 
+                Key=f'processed_videos/{final_filename}', 
+                Body=clean_file
+            )
+    except Exception as e:
+        print(f"Cloud upload skipped: {e}")
+        
+    # 5. Clean up local files
+    try:
+        os.remove(input_filename)
+        os.remove(trimmed_filename)
+    except Exception:
+        pass
+
+    # 🌟 3. Fixed the indentation here! 
+    if not is_pro:
+        db.deduct_credit(user_id)
+        print(f"💸 Credit deducted! Remaining: {credits_left - 1}")
+        
+    return {"message": "Success!", "file_name": f"final_clipcut_{file.filename}"}
+
+
+@app.get("/test-db")
+def test_database():
+    user_data = db.get_or_create_user("ceo@vaniconnect.com")
+    return {"message": "Database is working perfectly!", "user_data": user_data}

auto_detect.py

@@ -0,0 +1,61 @@
+import cv2
+import easyocr
+import os
+
+# Initialize the EasyOCR reader
+reader = easyocr.Reader(['mr', 'hi', 'en'], gpu=False) 
+
+def find_text_watermark(file_path):
+    """
+    Smartly reads an image OR grabs the first frame of a video, 
+    finds text, and returns x, y, w, h.
+    """
+    print(f"🤖 AI Auto: Scanning {file_path} for text watermarks...")
+    
+    # 1. SMART CHECK: Is this a video or a photo?
+    is_video = file_path.lower().endswith(('.mp4', '.mov', '.avi'))
+    
+    if is_video:
+        print("🎬 Video detected! Extracting first frame...")
+        cap = cv2.VideoCapture(file_path)
+        success, img = cap.read()
+        cap.release()
+        if not success:
+            print("❌ Could not read video frame.")
+            return None
+    else:
+        print("📸 Photo detected! Reading image...")
+        img = cv2.imread(file_path)
+        if img is None:
+            print("❌ Could not read the image file.")
+            return None
+
+    # 2. Ask EasyOCR to find text in the frame/image
+    results = reader.readtext(img, detail=1)
+
+    if not results:
+        print("❌ AI Auto could not find any text.")
+        return None
+
+    # 3. Find the biggest/most confident text box
+    best_box = results[0][0] 
+    
+    x1 = int(best_box[0][0])
+    y1 = int(best_box[0][1])
+    x2 = int(best_box[2][0])
+    y2 = int(best_box[2][1])
+
+    # 4. Calculate x, y, w, h with padding
+    x = x1
+    y = y1
+    w = x2 - x1
+    h = y2 - y1
+
+    padding = 50
+    x = max(0, x - padding)
+    y = max(0, y - padding)
+    w = w + (padding * 2)
+    h = h + (padding * 2)
+
+    print(f"🎯 AI Auto Found Target! Coordinates: x={x}, y={y}, w={w}, h={h}")
+    return {"x": x, "y": y, "w": w, "h": h}

bg_remove.py

@@ -0,0 +1,66 @@
+from rembg import remove, new_session
+from PIL import Image
+import os
+
+def remove_background_web(input_path, output_path):
+    try:
+        # 1. Open the image and force it into RGBA (Red, Green, Blue, Alpha) mode
+        img = Image.open(input_path).convert("RGBA")
+        
+        # 🌟 THE COLOR FIX: Save the original vibrant color profile!
+        icc_profile = img.info.get('icc_profile')
+        
+        # --- THE BULLETPROOF RAM FIX ---
+        img.thumbnail((2048, 2048), Image.Resampling.LANCZOS)
+        
+        my_session = new_session("isnet-general-use")
+
+        # 2. Ask the AI to ONLY generate the cut-out mask (Black & White silhouette)
+        print("🧠 AI generating precision mask...")
+        mask = remove(
+            img, 
+            session=my_session,
+            only_mask=True, # 🌟 THE SECRET SAUCE: Do not let AI touch the colors!
+            alpha_matting=True,
+            alpha_matting_foreground_threshold=200, 
+            alpha_matting_background_threshold=15,
+            alpha_matting_erode_size=5              
+        )
+
+        # 3. Stamp the AI's mask onto our untouched, beautifully colored original image!
+        img.putalpha(mask)
+
+        # 4. Save the final PNG, injecting the original color profile back inside
+        print("💾 Saving with 100% original color accuracy...")
+        img.save(output_path, format="PNG", icc_profile=icc_profile)
+            
+        return True
+    except Exception as e:
+        print(f"🚨 Background Removal Failed: {e}")
+        return False
+
+# ==========================================
+# 🌟 PRO TIER: BACKGROUND REPLACER
+# ==========================================
+def apply_pro_background(transparent_img_path, output_path, bg_color_hex=None, bg_image_path=None):
+    """ Takes a transparent PNG and adds a solid color or custom image behind it. """
+    try:
+        fg = Image.open(transparent_img_path).convert("RGBA")
+        
+        if bg_image_path:
+            bg = Image.open(bg_image_path).convert("RGBA")
+            bg = bg.resize(fg.size, Image.Resampling.LANCZOS)
+            bg.paste(fg, (0, 0), fg)
+            bg.convert("RGB").save(output_path, format="JPEG")
+            return True
+            
+        elif bg_color_hex:
+            bg = Image.new("RGBA", fg.size, bg_color_hex)
+            bg.paste(fg, (0, 0), fg)
+            bg.convert("RGB").save(output_path, format="JPEG")
+            return True
+            
+        return False
+    except Exception as e:
+        print(f"🚨 Pro Background Error: {e}")
+        return False

db.py

@@ -0,0 +1,37 @@
+import firebase_admin
+import os
+import json
+from firebase_admin import credentials, firestore
+
+# 1. Connect to the Firebase Vault using your Master Key
+# (Ensure your 'firebase_key.json' file is inside the same folder as this file!)
+firebase_secret = os.environ.get("FIREBASE_KEY")
+cred = credentials.Certificate(json.loads(firebase_secret))
+
+# Prevent the server from crashing if it reloads and tries to initialize twice
+if not firebase_admin._apps:
+    firebase_admin.initialize_app(cred)
+
+# 2. Get the database instance
+db = firestore.client()
+
+def get_user(user_uid):
+    """Fetches the user from Firebase to check their credits"""
+    user_ref = db.collection('users').document(user_uid)
+    doc = user_ref.get()
+    
+    if doc.exists:
+        return doc.to_dict()
+    else:
+        return None
+
+# We keep this old function name so your app.py doesn't immediately crash!
+def get_or_create_user(user_uid):
+    return get_user(user_uid)
+
+def deduct_credit(user_uid):
+    """Subtracts 1 credit from the user after a successful AI generation"""
+    user_ref = db.collection('users').document(user_uid)
+    user_ref.update({
+        "free_credits": firestore.Increment(-1)
+    })

enhance_photo.py

@@ -0,0 +1,58 @@
+import cv2
+from cv2 import dnn_superres
+import numpy as np
+
+def enhance_photo_web(input_path, output_path, factor=4, face_restoration=True, color_correction=True):
+    try:
+        print(f"🧠 AI Engine starting: Reading {input_path}")
+        img = cv2.imread(input_path)
+        
+        if img is None:
+            return False
+
+        # 1. THE RELAXED MEMORY SHIELD
+        max_dim = 1600 
+        height, width = img.shape[:2]
+        if max(height, width) > max_dim:
+            scale = max_dim / max(height, width)
+            img = cv2.resize(img, (int(width * scale), int(height * scale)), interpolation=cv2.INTER_LANCZOS4)
+
+        # 🌟 2. SAFE COLOR CORRECTION
+        if color_correction:
+            # We gently lift shadows without crushing the blacks or muddying the image
+            lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+            l, a, b = cv2.split(lab)
+            
+            # Lowered the clipLimit to 1.2. This prevents the "dirty" look on selfies!
+            clahe = cv2.createCLAHE(clipLimit=1.2, tileGridSize=(8,8))
+            cl = clahe.apply(l)
+            
+            limg = cv2.merge((cl,a,b))
+            img = cv2.cvtColor(limg, cv2.COLOR_LAB2BGR)
+            
+            # (Notice I completely removed the cv2.detailEnhance line that was ruining it!)
+
+        # 3. FAST AI UPSCALING (FSRCNN)
+        print("⚡ Booting up FSRCNN Neural Network...")
+        sr = dnn_superres.DnnSuperResImpl_create()
+        model_path = "FSRCNN_x4.pb" 
+        sr.readModel(model_path)
+        sr.setModel("fsrcnn", 4) 
+        
+        result = sr.upsample(img)
+
+        # ✨ 4. CLEAN SHARPENING
+        if face_restoration:
+            print("✨ Applying clean unsharp mask...")
+            # The aggressive matrix made noisy photos look terrible. 
+            # This Gaussian approach is much safer for skin and faces.
+            gaussian_blur = cv2.GaussianBlur(result, (5, 5), 0)
+            result = cv2.addWeighted(result, 1.5, gaussian_blur, -0.5, 0)
+
+        cv2.imwrite(output_path, result)
+        print(f"✅ SUCCESS: Photo enhanced cleanly!")
+        return True
+
+    except Exception as e:
+        print(f"❌ PYTHON AI ERROR: {str(e)}")
+        return False

enhance_video.py

@@ -0,0 +1,64 @@
+from moviepy.editor import VideoFileClip
+import cv2
+import numpy as np
+
+def enhance_video_smartly(input_path, output_path, resolution="1080p FHD", fps_60=True, denoise=True):
+    """Turbo Mode: Video Enhancement matched to your React UI!"""
+    try:
+        print(f"🎬 Starting Video Engine | Res: {resolution} | 60FPS: {fps_60} | Denoise: {denoise}")
+        
+        # 1. Load the video
+        clip = VideoFileClip(input_path)
+        
+        # 2. RESOLUTION UPGRADE
+        # Warning: True 4K on a CPU takes hours. For MVP, we use MoviePy's fast resize.
+        if resolution == "4K UHD":
+            print("📺 Scaling to 4K UHD...")
+            clip = clip.resize(height=2160)
+        else:
+            print("📺 Scaling to 1080p FHD...")
+            # If the video is already 1080p, we skip resizing to save massive processing time!
+            if clip.h < 1080:
+                clip = clip.resize(height=1080)
+
+        # 3. FPS INTERPOLATION
+        target_fps = clip.fps
+        if fps_60:
+            print("🎞️ Upconverting to 60 FPS...")
+            target_fps = 60
+            # MoviePy will automatically duplicate/blend frames to hit 60fps!
+
+        # 4. FRAME-BY-FRAME AI MATH
+        def process_frame(frame):
+            # Boost contrast slightly so it pops
+            enhanced = cv2.convertScaleAbs(frame, alpha=1.1, beta=5)
+            
+            # If Denoise is ON, apply a Bilateral Filter (Removes grain, keeps edges sharp)
+            if denoise:
+                enhanced = cv2.bilateralFilter(enhanced, d=5, sigmaColor=25, sigmaSpace=25)
+                
+            return enhanced
+
+        # Apply the visual filters
+        print("⚙️ Processing frames... (This will take some time on a CPU!)")
+        final_clip = clip.fl_image(process_frame)
+
+        # 5. Export
+        final_clip.write_videofile(
+            output_path, 
+            codec='libx264', 
+            audio_codec='aac',
+            fps=target_fps, # Force the new FPS here!
+            logger=None 
+        )
+        
+        # Free up computer RAM
+        clip.close()
+        final_clip.close()
+        
+        print("✅ SUCCESS: Video Enhanced!")
+        return True
+        
+    except Exception as e:
+        print(f"🚨 Enhancement Error: {e}")
+        return False

main_photo.py

@@ -0,0 +1,58 @@
+import cv2
+import numpy as np
+import os
+
+def remove_photo_watermark_web(input_path, output_path, x, y, w, h, style="Standard AI Inpaint"):
+    if not os.path.exists(input_path):
+        return False
+        
+    img = cv2.imread(input_path)
+    if img is None:
+        return False
+        
+    img_h, img_w = img.shape[:2]
+    
+    # Safety check: Keep the coordinates inside the image
+    x = max(0, min(x, img_w - 1))
+    y = max(0, min(y, img_h - 1))
+    w = max(1, min(w, img_w - x))
+    h = max(1, min(h, img_h - y))
+    
+    if "Heavy Blur" in style:
+        roi = img[y:y+h, x:x+w]
+        k_size = max(15, min(w, h) // 2)
+        if k_size % 2 == 0: k_size += 1
+        img[y:y+h, x:x+w] = cv2.GaussianBlur(roi, (k_size, k_size), 0)
+        
+    else:
+        # THE MARGIN TRICK: We grab an extra 30 pixels of background around the logo
+        margin = 30
+        y1 = max(0, y - margin)
+        y2 = min(img_h, y + h + margin)
+        x1 = max(0, x - margin)
+        x2 = min(img_w, x + w + margin)
+        
+        roi = img[y1:y2, x1:x2]
+        mask = np.zeros(roi.shape[:2], dtype=np.uint8)
+        
+        local_y = y - y1
+        local_x = x - x1
+        
+        # We tell the AI EXACTLY where the logo is inside this bordered box
+        cv2.rectangle(mask, (local_x, local_y), (local_x + w, local_y + h), 255, -1)
+        
+        if "Smart Text Eraser" in style:
+            gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
+            _, text_mask = cv2.threshold(gray, 180, 255, cv2.THRESH_BINARY)
+            final_mask = cv2.bitwise_and(text_mask, mask)
+            kernel = np.ones((3,3), np.uint8)
+            final_mask = cv2.dilate(final_mask, kernel, iterations=1)
+            cleaned_roi = cv2.inpaint(roi, final_mask, 3, cv2.INPAINT_TELEA)
+        else:
+            cleaned_roi = cv2.inpaint(roi, mask, 3, cv2.INPAINT_TELEA)
+            
+        # Paste the cleaned area perfectly back into the image
+        img[y1:y2, x1:x2] = cleaned_roi
+
+    cv2.imwrite(output_path, img)
+    return True

main_video.py

@@ -0,0 +1,216 @@
+import cv2
+import numpy as np
+import os
+import shutil
+import subprocess
+import urllib.request
+import onnxruntime as ort
+from moviepy.editor import VideoFileClip
+
+# 🚀 INITIALIZE THE LAMA AI ENGINE GLOBALLY
+MODEL_PATH = os.path.join(os.path.dirname(__file__), "models", "big-lama.onnx")
+
+if not os.path.exists(MODEL_PATH):
+    print("📥 AI Model file not found. Auto-downloading from production mirror...")
+    os.makedirs(os.path.dirname(MODEL_PATH), exist_ok=True)
+    url = "https://huggingface.co/Carve/LaMa-ONNX/resolve/main/lama_fp32.onnx"
+    try:
+        req = urllib.request.Request(
+            url, 
+            headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
+        )
+        with urllib.request.urlopen(req) as response, open(MODEL_PATH, 'wb') as out_file:
+            shutil.copyfileobj(response, out_file)
+        print("✅ AI Model downloaded successfully!")
+    except Exception as download_err:
+        print(f"🚨 Mirror download failed ({download_err}).")
+
+try:
+    if os.path.exists(MODEL_PATH):
+        opts = ort.SessionOptions()
+        opts.intra_op_num_threads = 1
+        opts.inter_op_num_threads = 1
+        opts.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+        
+        providers = ['CUDAExecutionProvider', 'CPUExecutionProvider']
+        ort_session = ort.InferenceSession(MODEL_PATH, sess_options=opts, providers=providers)
+        print("🚀 LaMa AI Inpainting Engine Initialized Safely!")
+    else:
+        ort_session = None
+except Exception as e:
+    print(f"⚠️ ONNX Session initialization failed ({e}). Falling back to classical.")
+    ort_session = None
+
+
+def remove_watermark_pro(input_path, output_path, x, y, w, h, mode="fast"):
+    """
+    Video Watermark Removal with adaptive dominant-color patching for seamless graphics removal.
+    """
+    global ort_session
+    
+    base_name = os.path.basename(input_path)
+    normalized_input = f"normalized_{base_name}.mp4"
+    
+    try:
+        conversion_cmd = [
+            "ffmpeg", "-y", "-i", input_path,
+            "-vcodec", "libx264", "-acodec", "aac",
+            "-pix_fmt", "yuv420p", "-preset", "ultrafast",
+            normalized_input
+        ]
+        subprocess.run(conversion_cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        processing_source = normalized_input
+    except Exception:
+        processing_source = input_path
+
+    cap = cv2.VideoCapture(processing_source)
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    
+    width = width if width % 2 == 0 else width - 1
+    height = height if height % 2 == 0 else height - 1
+
+    temp_output = f"temp_pro_{base_name}"
+    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+    out = cv2.VideoWriter(temp_output, fourcc, fps, (width, height))
+
+    # Calculate bounded crop area coordinates for AI mode
+    padding = 16
+    x1 = max(0, int(x) - padding)
+    y1 = max(0, int(y) - padding)
+    x2 = min(width, int(x + w) + padding)
+    y2 = min(height, int(y + h) + padding)
+
+    crop_w = x2 - x1
+    crop_h = y2 - y1
+    if crop_w % 8 != 0: x2 = min(width, x2 + (8 - (crop_w % 8)))
+    if crop_h % 8 != 0: y2 = min(height, y2 + (8 - (crop_h % 8)))
+
+    img_key, mask_key = None, None
+    if ort_session is not None and mode == "ai":
+        try:
+            inputs = ort_session.get_inputs()
+            for node in inputs:
+                if "mask" in node.name.lower():
+                    mask_key = node.name
+                else:
+                    img_key = node.name
+        except Exception:
+            ort_session = None
+
+    frames_processed = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+            
+        if frame.shape[1] != width or frame.shape[0] != height:
+            frame = cv2.resize(frame, (width, height))
+            
+        mask = np.zeros(frame.shape[:2], dtype=np.uint8)
+        cv2.rectangle(mask, (int(x), int(y)), (int(x + w), int(y + h)), 255, -1)
+        
+        if mode == "ai" and ort_session is not None and (y2 > y1 and x2 > x1):
+            try:
+                crop_frame = frame[y1:y2, x1:x2]
+                crop_mask = mask[y1:y2, x1:x2]
+                orig_h, orig_w = crop_frame.shape[:2]
+
+                crop_frame_resized = cv2.resize(crop_frame, (512, 512))
+                crop_mask_resized = cv2.resize(crop_mask, (512, 512))
+                crop_rgb = cv2.cvtColor(crop_frame_resized, cv2.COLOR_BGR2RGB)
+                
+                img_tensor = crop_rgb.astype(np.float32) / 255.0
+                img_tensor = np.transpose(img_tensor, (2, 0, 1))[np.newaxis, ...]
+                
+                mask_tensor = crop_mask_resized.astype(np.float32)
+                mask_tensor = np.where(mask_tensor > 0, 1.0, 0.0).astype(np.float32)
+                mask_tensor = mask_tensor[np.newaxis, np.newaxis, ...]
+
+                ai_outputs = ort_session.run(None, {img_key: img_tensor, mask_key: mask_tensor})
+
+                ai_output = ai_outputs[0][0]
+                ai_output = np.transpose(ai_output, (1, 2, 0))
+                ai_output = np.clip(ai_output * 255.0, 0, 255).astype(np.uint8)
+                clean_crop_bgr = cv2.cvtColor(ai_output, cv2.COLOR_RGB2BGR)
+
+                frame[y1:y2, x1:x2] = cv2.resize(clean_crop_bgr, (orig_w, orig_h))
+            except Exception:
+                frame = cv2.inpaint(frame, mask, 1, cv2.INPAINT_TELEA)
+        else:
+            # ⚡ HIGH-FIDELITY FAST MODE: Content-Aware Dominant Color Patching
+            ymin, ymax = max(0, int(y)), min(height, int(y + h))
+            xmin, xmax = max(0, int(x)), min(width, int(x + w))
+            
+            if (ymax > ymin) and (xmax > xmin):
+                # Sample 4 pixels wide around the boundary of the selection box
+                sample_top = frame[max(0, ymin-4):ymin, xmin:xmax]
+                sample_bottom = frame[ymax:min(height, ymax+4), xmin:xmax]
+                sample_left = frame[ymin:ymax, max(0, xmin-4):xmin]
+                sample_right = frame[ymin:ymax, xmax:min(width, xmax+4)]
+                
+                samples = []
+                for s in [sample_top, sample_bottom, sample_left, sample_right]:
+                    if s.size > 0:
+                        samples.append(s.reshape(-1, 3))
+                
+                if samples:
+                    # Use median value to completely disregard text letter colors and extract pure background tint
+                    all_pixels = np.vstack(samples)
+                    bg_color = np.median(all_pixels, axis=0).astype(int)
+                    
+                    # Paint a clean, solid patch over the watermark zone matching the background perfectly
+                    cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (int(bg_color[0]), int(bg_color[1]), int(bg_color[2])), -1)
+                    
+                    # Smooth the local border bounds slightly so it blends organically
+                    if xmin > 2 and xmax < width - 2 and ymin > 2 and ymax < height - 2:
+                        roi = frame[ymin-2:ymax+2, xmin-2:xmax+2]
+                        frame[ymin-2:ymax+2, xmin-2:xmax+2] = cv2.GaussianBlur(roi, (3, 3), 0)
+                else:
+                    frame = cv2.inpaint(frame, mask, 1, cv2.INPAINT_TELEA)
+            else:
+                frame = cv2.inpaint(frame, mask, 1, cv2.INPAINT_TELEA)
+
+        out.write(frame)
+        frames_processed += 1
+
+    cap.release()
+    out.release()
+
+    if frames_processed == 0:
+        if os.path.exists(temp_output): os.remove(temp_output)
+        if os.path.exists(normalized_input): os.remove(normalized_input)
+        return False 
+
+    try:
+        original_clip = VideoFileClip(processing_source)
+        processed_clip = VideoFileClip(temp_output)
+        
+        if original_clip.audio is not None:
+            final_video = processed_clip.set_audio(original_clip.audio)
+        else:
+            final_video = processed_clip
+            
+        final_video.write_videofile(
+            output_path, codec="libx264", audio_codec="aac", 
+            preset="ultrafast", threads=1,
+            ffmpeg_params=["-movflags", "+faststart"], logger=None
+        )
+        original_clip.close()
+        processed_clip.close()
+    except Exception:
+        try:
+            conversion_command = [
+                "ffmpeg", "-y", "-i", temp_output, 
+                "-vcodec", "libx264", "-pix_fmt", "yuv420p",
+                "-movflags", "+faststart", "-an", output_path
+            ]
+            subprocess.run(conversion_command, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        except Exception:
+            shutil.copy(temp_output, output_path)
+    finally:
+        if os.path.exists(temp_output): os.remove(temp_output)
+        if os.path.exists(normalized_input): os.remove(normalized_input)
+
+    return True

process_test.py

@@ -0,0 +1,22 @@
+from moviepy.editor import VideoFileClip
+
+print("🎬 Starting Phase 2: Video Processing Test...")
+
+# 1. Load the 18-second video we downloaded in Phase 1
+try:
+    video = VideoFileClip("test_video.mp4")
+except Exception as e:
+    print("❌ Error: Make sure test_video.mp4 is in your folder!")
+    exit()
+
+# 2. Simulate "Watermark Removal" by cropping the bottom 10%
+# (We will plug your exact old logic in here later!)
+print("✂️ Cropping the bottom of the video to hide watermarks...")
+width, height = video.size
+clean_video = video.crop(y1=0, y2=height * 0.9)
+
+# 3. Save the new video
+print("⏳ Processing... (This might take a minute, computers have to work hard for video!)")
+clean_video.write_videofile("clean_video.mp4", codec="libx264", audio_codec="aac")
+
+print("✅ SUCCESS! Look in your folder for the new clean_video.mp4!")

requirements.txt

@@ -0,0 +1,64 @@
+annotated-doc
+annotated-types
+anyio
+attrs
+boto3
+botocore
+certifi
+charset-normalizer
+click
+colorama
+decorator
+fastapi
+flatbuffers
+h11
+idna
+ImageIO
+imageio-ffmpeg
+jmespath
+jsonschema
+jsonschema-specifications
+lazy-loader
+llvmlite
+mpmath
+networkx
+numba
+numpy
+onnxruntime
+opencv-contrib-python-headless
+packaging
+pillow
+platformdirs
+pooch
+proglog
+protobuf
+pydantic
+pydantic_core
+PyMatting
+python-dateutil
+python-dotenv
+python-multipart
+referencing
+rembg
+requests
+rpds-py
+s3transfer
+scikit-image
+scipy
+six
+starlette
+sympy
+tifffile
+tqdm
+typing-inspection
+typing_extensions
+urllib3
+uvicorn
+slowapi
+razorpay
+firebase-admin
+moviepy==1.0.3
+easyocr
+onnxruntime==1.18.0
+numpy==1.26.4
+opencv-python-headless==4.9.0.80

trim_video.py

@@ -0,0 +1,136 @@
+from moviepy.editor import VideoFileClip
+import cv2
+import os
+import zipfile  # 🌟 NEW: Needed for packing the batch clips
+import math     # 🌟 NEW: Needed to calculate how many clips to make
+
+def trim_video(input_path, output_path, start_sec, end_sec):
+    """ Cuts the video to the specified time range. """
+    try:
+        # Load the video and explicitly grab the audio
+        video = VideoFileClip(input_path)
+        new_video = video.subclip(start_sec, end_sec)
+        
+        new_video.write_videofile(
+            output_path, 
+            codec="libx264", 
+            audio_codec="aac", # 🌐 Force Web-Safe Audio
+            preset="ultrafast", 
+            threads=8, 
+            logger=None
+        )
+        
+        # 🛑 WINDOWS FIX: Explicitly close everything to free RAM!
+        video.close()
+        new_video.close()
+        return True
+    except Exception as e:
+        print(f"Trim Error: {e}")
+        return False
+
+def add_professional_text(input_path, output_path, text="VaniConnect AI"):
+    """ Adds a professional text overlay using OpenCV. """
+    try:
+        cap = cv2.VideoCapture(input_path)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        
+        temp_v = "downloads/temp_text.mp4" 
+        out = cv2.VideoWriter(temp_v, cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))
+
+        while True:
+            ret, frame = cap.read()
+            if not ret: break
+            
+            # Add text with a subtle shadow for readability
+            cv2.putText(frame, text, (52, height - 48), cv2.FONT_HERSHEY_DUPLEX, 1.5, (0, 0, 0), 3)
+            cv2.putText(frame, text, (50, height - 50), cv2.FONT_HERSHEY_DUPLEX, 1.5, (255, 255, 255), 2)
+            out.write(frame)
+            
+        cap.release()
+        out.release()
+
+        # 🔊 THE AUDIO FIX: Explicitly rip the audio and force it onto the new video
+        original = VideoFileClip(input_path)
+        processed = VideoFileClip(temp_v)
+        
+        # Only set audio if the original video actually had sound!
+        if original.audio is not None:
+            final = processed.set_audio(original.audio)
+        else:
+            final = processed
+
+        final.write_videofile(
+            output_path, 
+            codec="libx264", 
+            audio_codec="aac", 
+            preset="ultrafast", 
+            threads=8, 
+            logger=None
+        )
+        
+        # 🛑 WINDOWS FIX: Explicitly close every single file!
+        original.close()
+        processed.close()
+        final.close()
+        
+        os.remove(temp_v)
+        return True
+    except Exception as e:
+        print(f"Text Overlay Error: {e}")
+        return False
+
+# ==========================================
+# 🌟 PRO TIER FEATURE: THE BATCH SPLITTER
+# ==========================================
+def split_video_into_parts(video_path, clip_duration_sec, output_folder):
+    """ Slices a long video into multiple equal parts and zips them up. """
+    try:
+        video = VideoFileClip(video_path)
+        total_duration = video.duration
+        
+        # Calculate how many full clips we get
+        number_of_clips = math.ceil(total_duration / clip_duration_sec)
+        
+        saved_files = []
+        base_name = os.path.basename(video_path).rsplit('.', 1)[0]
+
+        for i in range(number_of_clips):
+            start_time = i * clip_duration_sec
+            end_time = min((i + 1) * clip_duration_sec, total_duration)
+            
+            # Skip tiny clips at the very end (less than 3 seconds)
+            if end_time - start_time < 3:
+                continue
+                
+            out_name = os.path.join(output_folder, f"{base_name}_part{i+1}.mp4")
+            
+            # Slice and save with turbo settings
+            clip = video.subclip(start_time, end_time)
+            print(f"✂️ Cutting Part {i+1}: {start_time}s to {end_time}s")
+            
+            clip.write_videofile(
+                out_name, 
+                codec="libx264", 
+                audio_codec="aac", 
+                preset="ultrafast", 
+                threads=4, 
+                logger=None
+            )
+            saved_files.append(out_name)
+        
+        video.close()
+        
+        # 📦 Zip them all up!
+        zip_filename = os.path.join(output_folder, f"{base_name}_Batch.zip")
+        print("📦 Zipping files together...")
+        with zipfile.ZipFile(zip_filename, 'w') as zipf:
+            for file in saved_files:
+                zipf.write(file, os.path.basename(file))
+                os.remove(file) # Delete the individual MP4s to save space
+                
+        return True, zip_filename
+    except Exception as e:
+        print(f"🚨 Batch Split Error: {e}")
+        return False, None

yt_down.py

@@ -0,0 +1,58 @@
+import yt_dlp
+import os
+import uuid
+
+def download_youtube_video(video_url, output_folder="downloads", quality="720p"):
+    try:
+        os.makedirs(output_folder, exist_ok=True)
+        
+        random_id = uuid.uuid4().hex[:8]
+        is_audio = (quality == "audio")
+        ext = "mp3" if is_audio else "mp4"
+        
+        safe_filename = f"yt_{random_id}.{ext}"
+        final_path = os.path.join(output_folder, safe_filename)
+
+        # Quality Mapping
+        if quality == "best":
+            format_str = 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best'
+        elif quality == "720p":
+            format_str = 'bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720][ext=mp4]/best'
+        elif quality == "480p":
+            format_str = 'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480][ext=mp4]/best'
+        elif quality == "audio":
+            format_str = 'bestaudio/best'
+        else:
+            format_str = 'best[ext=mp4]/best' 
+            
+        ydl_opts = {
+            'format': format_str, 
+            'outtmpl': final_path,  
+            'quiet': False,
+            'no_warnings': True,
+            'source_address': '0.0.0.0'  
+        }
+        
+        if is_audio:
+            ydl_opts['postprocessors'] = [{
+                'key': 'FFmpegExtractAudio',
+                'preferredcodec': 'mp3',
+                'preferredquality': '192',
+            }]
+        else:
+            ydl_opts['merge_output_format'] = 'mp4'
+        
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            # 🌟 THE UPGRADE: We extract info AND download at the same time!
+            info_dict = ydl.extract_info(video_url, download=True)
+            
+            # Grab the metadata to send to React
+            title = info_dict.get('title', 'Unknown Media')
+            thumbnail = info_dict.get('thumbnail', '')
+            
+        # 🌟 Return all 3 pieces of data!
+        return safe_filename, title, thumbnail
+            
+    except Exception as e:
+        print(f"🚨 Download Error: {e}")
+        return None, None, None