Upload 10 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* 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
+avatar_female.png filter=lfs diff=lfs merge=lfs -text
+avatar_male.png filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,29 @@
+# ---- BubbleGuard (FastAPI) – Dockerfile for Hugging Face Spaces ----
+FROM python:3.10-slim
+
+# Environment & pip behavior
+ENV DEBIAN_FRONTEND=noninteractive \
+    PIP_NO_CACHE_DIR=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# System deps (ffmpeg needed for faster-whisper)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+ && rm -rf /var/lib/apt/lists/*
+
+# Workdir
+WORKDIR /app
+
+# Python deps first (better layer caching)
+COPY requirements.txt .
+RUN python -m pip install --upgrade pip && pip install -r requirements.txt
+
+# App code + static
+COPY . .
+
+# Hugging Face injects $PORT. Host is 0.0.0.0 for container networking.
+ENV HOST=0.0.0.0
+
+# Start the app (main.py loads assets from Google Drive, then runs uvicorn)
+CMD ["python", "main.py"]

app_server.py

@@ -0,0 +1,475 @@
+# server_app.py — BubbleGuard API + Dating-style Web Chat (Static UI)
+# Version: 1.6.4 (mapping & greetings fix)
+# Changes vs 1.6.3:
+# - Robust SAFE/UNSAFE index resolution (env override → name hints → probe fallback)
+# - Friendly greeting allow-list so benign openers are always SAFE
+# - Startup log prints resolved SAFE_ID/UNSAFE_ID and id2label
+# Author: Amir
+
+import io
+import os
+import re
+import uuid
+import pathlib
+import tempfile
+import subprocess
+import unicodedata
+from typing import Dict
+
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+
+import torch
+import joblib
+import torchvision
+from torchvision import transforms
+from transformers import RobertaTokenizerFast, AutoModelForSequenceClassification
+from PIL import Image
+from faster_whisper import WhisperModel
+
+# -------------------------- Paths & Config --------------------------
+BASE = pathlib.Path(__file__).resolve().parent
+TEXT_DIR = BASE / "Text"
+IMG_DIR = BASE / "Image"
+AUD_DIR = BASE / "Audio"
+STATIC_DIR = BASE / "static"
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+IMG_UNSAFE_THR = float(os.getenv("IMG_UNSAFE_THR", "0.5"))
+WHISPER_MODEL_NAME = os.getenv("WHISPER_MODEL", "base")  # large-v2 | medium | small | base | tiny
+
+# Text thresholds and heuristics
+TEXT_UNSAFE_THR = float(os.getenv("TEXT_UNSAFE_THR", "0.60"))  # normal texts
+SHORT_MSG_MAX_TOKENS = int(os.getenv("SHORT_MSG_MAX_TOKENS", "6"))  # <= N tokens = "short"
+SHORT_MSG_UNSAFE_THR = float(os.getenv("SHORT_MSG_UNSAFE_THR", "0.90"))  # short msgs require very high unsafe to block
+
+app = FastAPI(title="BubbleGuard API", version="1.6.4")
+
+# CORS open for demo; restrict in production
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# -------------------------- Text Classifier -------------------------
+try:
+    tok = RobertaTokenizerFast.from_pretrained(TEXT_DIR, local_files_only=True)
+    txtM = AutoModelForSequenceClassification.from_pretrained(
+        TEXT_DIR, local_files_only=True
+    ).to(DEVICE).eval()
+except Exception as e:
+    raise RuntimeError(f"Failed to load text model from {TEXT_DIR}: {e}")
+
+# ------------------------ Label mapping (robust) --------------------
+# Strategy:
+# 1) Allow SAFE_ID/UNSAFE_ID env overrides if you want to pin indices explicitly.
+# 2) Try to infer from label names (supports synonyms like "ok", "benign", "toxic", etc.).
+# 3) Probe the model with obviously safe samples; whichever class receives higher mean prob is SAFE.
+
+SAFE_LABEL_HINTS = {"safe", "ok", "clean", "benign", "non-toxic", "non_toxic", "non toxic"}
+UNSAFE_LABEL_HINTS = {"unsafe", "toxic", "abuse", "harm", "offense", "nsfw", "not_safe", "not safe"}
+
+def _infer_ids_by_name(model) -> (int, int):
+    try:
+        id2label = {int(k): str(v).lower() for k, v in model.config.id2label.items()}
+    except Exception:
+        return None, None
+    safe_idx = None; unsafe_idx = None
+    for i, name in id2label.items():
+        if any(h in name for h in SAFE_LABEL_HINTS):
+            safe_idx = i
+        if any(h in name for h in UNSAFE_LABEL_HINTS):
+            unsafe_idx = i
+    if safe_idx is not None and unsafe_idx is None:
+        unsafe_idx = 1 - safe_idx
+    if unsafe_idx is not None and safe_idx is None:
+        safe_idx = 1 - unsafe_idx
+    return safe_idx, unsafe_idx
+
+@torch.no_grad()
+def _infer_ids_by_probe(model, tok, device) -> (int, int):
+    samples = ["hi", "hello", "how are you", "nice to meet you", "thanks"]
+    enc = tok(samples, return_tensors="pt", truncation=True, padding=True, max_length=64)
+    enc = {k: v.to(device) for k, v in enc.items()}
+    logits = model(**enc).logits  # [B, 2]
+    probs = torch.softmax(logits, dim=-1).mean(0)  # [2]
+    safe_idx = int(torch.argmax(probs).item())
+    unsafe_idx = 1 - safe_idx
+    return safe_idx, unsafe_idx
+
+def _resolve_safe_unsafe_ids(model, tok, device) -> (int, int):
+    # 1) Env overrides (pin explicit indices if you know them)
+    s_env = os.getenv("SAFE_ID"); u_env = os.getenv("UNSAFE_ID")
+    if s_env is not None and u_env is not None:
+        return int(s_env), int(u_env)
+    # 2) Name-based inference
+    s, u = _infer_ids_by_name(model)
+    if s is not None and u is not None:
+        return s, u
+    # 3) Probe fallback
+    return _infer_ids_by_probe(model, tok, device)
+
+SAFE_ID, UNSAFE_ID = _resolve_safe_unsafe_ids(txtM, tok, DEVICE)
+print(f"[BubbleGuard] SAFE_ID={SAFE_ID}  UNSAFE_ID={UNSAFE_ID}  id2label={getattr(txtM.config, 'id2label', None)}")
+
+# ------------------------ Normalization utils -----------------------
+def normalize(text: str) -> str:
+    """
+    Normalize for rules:
+    - Unicode NFKC (compatibility composition)
+    - Curly quotes/apostrophes -> straight
+    - Lowercase
+    - Strip to letters/numbers/space/' only (keeps apostrophes for don't)
+    - Collapse whitespace
+    """
+    if not isinstance(text, str):
+        return ""
+    t = unicodedata.normalize("NFKC", text)
+    t = t.replace("’", "'").replace("‘", "'").replace("“", '"').replace("”", '"')
+    t = t.lower()
+    t = re.sub(r"[^a-z0-9\s']", " ", t)
+    t = re.sub(r"\s+", " ", t).strip()
+    return t
+
+# Allow-list: short, obviously harmless negations (lowercase, punctuation-light)
+SAFE_PHRASES = [
+    r"^i don'?t$",
+    r"^i do not$",
+    r"^don'?t$",
+    r"^no$",
+    r"^not really$",
+    r"^i wouldn'?t$",
+    r"^i would not$",
+    r"^i don'?t like$",  # common polite dislike
+    r"^i woulde?n'?t$",  # catches wouldn't / wouldent
+]
+SAFE_RE = re.compile("|".join(SAFE_PHRASES))
+
+# Extra guard for one-word/very short negation replies
+NEGATION_ONLY = re.compile(r"^(?:i\s+)?(?:do\s+not|don'?t|no|not)$")
+
+# --- Neutral dislike heuristics (polite preferences) ---
+NEUTRAL_DISLIKE = re.compile(r"^i don'?t like(?:\s+to)?\b")
+
+# Things we should NOT relax on (protected classes / direct people)
+SENSITIVE_TERMS = {
+    "people", "you", "him", "her", "them", "men", "women", "girls", "boys",
+    "muslim", "christian", "jew", "jews", "black", "white", "asian",
+    "gay", "lesbian", "trans", "transgender", "disabled",
+    "immigrants", "refugees", "poor", "old", "elderly", "fat", "skinny"
+}
+
+# Profanity/sexual terms that should stay blocked regardless
+PROFANITY_TERMS = {
+    "fuck", "shit", "bitch", "pussy", "dick", "cunt", "slut", "whore"
+}
+
+# Friendly greetings / openers that should always be SAFE
+GREETINGS = [
+    r"^hi$",
+    r"^hello$",
+    r"^hey(?: there)?$",
+    r"^how are (?:you|u)\b.*$",
+    r"^good (?:morning|afternoon|evening)\b.*$",
+    r"^what'?s up\b.*$",
+    r"^how'?s it going\b.*$",
+]
+GREETING_RE = re.compile("|".join(GREETINGS))
+
+@torch.no_grad()
+def text_safe_payload(text: str) -> Dict:
+    # Normalize once for all rule checks (fixes mobile smart quotes)
+    clean = normalize(text)
+    toks = clean.split()
+
+    # --- HARD RULE A: single-word profanity is always UNSAFE ---
+    if len(toks) == 1 and toks[0] in PROFANITY_TERMS:
+        probs = [0.0, 0.0]; probs[UNSAFE_ID] = 1.0
+        return {
+            "safe": False,
+            "unsafe_prob": 1.0,
+            "label": "UNSAFE",
+            "probs": probs,
+            "tokens": 1,
+            "reason": "profanity_single_word",
+            "params": {
+                "TEXT_UNSAFE_THR": TEXT_UNSAFE_THR,
+                "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS,
+                "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR,
+            },
+        }
+
+    # --- HARD RULE B: short text with any profanity => UNSAFE ---
+    if len(toks) <= SHORT_MSG_MAX_TOKENS and any(t in PROFANITY_TERMS for t in toks):
+        probs = [0.0, 0.0]; probs[UNSAFE_ID] = 1.0
+        return {
+            "safe": False,
+            "unsafe_prob": 1.0,
+            "label": "UNSAFE",
+            "probs": probs,
+            "tokens": len(toks),
+            "reason": "profanity_short_text",
+            "params": {
+                "TEXT_UNSAFE_THR": TEXT_UNSAFE_THR,
+                "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS,
+                "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR,
+            },
+        }
+
+    # 1) Explicit allow-list / negation-only
+    if SAFE_RE.match(clean) or NEGATION_ONLY.match(clean):
+        probs = [0.0, 0.0]; probs[SAFE_ID] = 1.0
+        return {
+            "safe": True,
+            "unsafe_prob": 0.0,
+            "label": "SAFE",
+            "probs": probs,
+            "tokens": len(toks),
+            "reason": "allow_list",
+            "params": {
+                "TEXT_UNSAFE_THR": TEXT_UNSAFE_THR,
+                "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS,
+                "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR,
+            },
+        }
+
+    # 1b) Friendly greetings: always SAFE
+    if GREETING_RE.match(clean):
+        probs = [0.0, 0.0]; probs[SAFE_ID] = 1.0
+        return {
+            "safe": True,
+            "unsafe_prob": 0.0,
+            "label": "SAFE",
+            "probs": probs,
+            "tokens": len(toks),
+            "reason": "greeting_allow",
+            "params": {
+                "TEXT_UNSAFE_THR": TEXT_UNSAFE_THR,
+                "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS,
+                "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR,
+            },
+        }
+
+    # 2) Neutral-dislike: "i don't like [food/activity/...]" but NOT people/groups/profanity
+    if NEUTRAL_DISLIKE.match(clean):
+        has_sensitive = any(term in clean for term in SENSITIVE_TERMS)
+        has_profanity = any(term in clean for term in PROFANITY_TERMS)
+        if not has_sensitive and not has_profanity:
+            # Run model lightly; be very lenient to still catch outliers
+            enc = tok(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
+            enc = {k: v.to(DEVICE) for k, v in enc.items()}
+            logits = txtM(**enc).logits[0]
+            probs = torch.softmax(logits, dim=-1).detach().cpu().tolist()
+            unsafe_prob = float(probs[UNSAFE_ID])
+            is_safe = unsafe_prob < 0.98
+            return {
+                "safe": bool(is_safe),
+                "unsafe_prob": unsafe_prob,
+                "label": "SAFE" if is_safe else "UNSAFE",
+                "probs": probs,
+                "tokens": int(enc["input_ids"].shape[1]),
+                "reason": "neutral_dislike_relaxed",
+                "params": {
+                    "TEXT_UNSAFE_THR": TEXT_UNSAFE_THR,
+                    "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS,
+                    "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR,
+                },
+            }
+
+    # 3) Normal model path (short-text heuristic etc.)
+    enc = tok(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
+    enc = {k: v.to(DEVICE) for k, v in enc.items()}
+    logits = txtM(**enc).logits[0]
+    probs = torch.softmax(logits, dim=-1).detach().cpu().tolist()
+    unsafe_prob = float(probs[UNSAFE_ID])
+    pred_idx = int(torch.argmax(logits))
+    num_tokens = int(enc["input_ids"].shape[1])
+
+    # Thresholds
+    if num_tokens <= SHORT_MSG_MAX_TOKENS:
+        is_safe = unsafe_prob < SHORT_MSG_UNSAFE_THR
+        reason = "short_msg_threshold"
+    else:
+        is_safe = unsafe_prob < TEXT_UNSAFE_THR
+        reason = "global_threshold"
+
+    # Robust label lookup (int or str key)
+    label = txtM.config.id2label.get(pred_idx, txtM.config.id2label.get(str(pred_idx), str(pred_idx)))
+    return {
+        "safe": bool(is_safe),
+        "unsafe_prob": unsafe_prob,
+        "label": label,
+        "probs": probs,
+        "tokens": num_tokens,
+        "reason": reason,
+        "params": {
+            "TEXT_UNSAFE_THR": TEXT_UNSAFE_THR,
+            "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS,
+            "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR,
+        },
+    }
+
+# -------------------------- Image Classifier ------------------------
+class SafetyResNet(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        base = torchvision.models.resnet50(weights=None)
+        self.feature_extractor = torch.nn.Sequential(*list(base.children())[:8])
+        self.pool = torch.nn.AdaptiveAvgPool2d(1)
+        self.classifier = torch.nn.Sequential(
+            torch.nn.Linear(2048, 512),
+            torch.nn.ReLU(True),
+            torch.nn.Dropout(0.30),
+            torch.nn.Linear(512, 2),
+        )
+
+    def forward(self, x):
+        x = self.pool(self.feature_extractor(x))
+        return self.classifier(torch.flatten(x, 1))
+
+try:
+    imgM = SafetyResNet().to(DEVICE)
+    imgM.load_state_dict(
+        torch.load(IMG_DIR / "resnet_safety_classifier.pth", map_location=DEVICE),
+        strict=True
+    )
+    imgM.eval()
+except Exception as e:
+    raise RuntimeError(f"Failed to load image model weights from {IMG_DIR}: {e}")
+
+img_tf = transforms.Compose([
+    transforms.Resize(256),
+    transforms.CenterCrop(224),
+    transforms.ToTensor(),
+    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+])
+
+@torch.no_grad()
+def image_safe_payload(pil_img: Image.Image) -> Dict:
+    x = img_tf(pil_img.convert("RGB")).unsqueeze(0).to(DEVICE)
+    logits = imgM(x)[0]
+    probs = torch.softmax(logits, dim=0).detach().cpu().tolist()
+    unsafe_p = float(probs[UNSAFE_ID])  # assumes class order [SAFE_ID, UNSAFE_ID]
+    return {"safe": unsafe_p < IMG_UNSAFE_THR, "unsafe_prob": unsafe_p, "probs": probs}
+
+# -------------------------- Audio (ASR -> NLP) ----------------------
+compute_type = "float16" if DEVICE == "cuda" else "int8"
+try:
+    asr = WhisperModel(WHISPER_MODEL_NAME, device=DEVICE, compute_type=compute_type)
+except Exception as e:
+    raise RuntimeError(f"Failed to load Whisper model '{WHISPER_MODEL_NAME}': {e}")
+
+try:
+    text_clf = joblib.load(AUD_DIR / "text_pipeline_balanced.joblib")
+except Exception as e:
+    raise RuntimeError(f"Failed to load audio text pipeline from {AUD_DIR}: {e}")
+
+def _ffmpeg_to_wav(src_bytes: bytes) -> bytes:
+    """Convert arbitrary browser audio to 16kHz mono WAV using ffmpeg. If ffmpeg is missing, raise a clear error."""
+    with tempfile.TemporaryDirectory() as td:
+        in_path = pathlib.Path(td) / f"in-{uuid.uuid4().hex}"
+        out_path = pathlib.Path(td) / "out.wav"
+        in_path.write_bytes(src_bytes)
+        cmd = ["ffmpeg", "-y", "-i", str(in_path), "-ac", "1", "-ar", "16000", str(out_path)]
+        try:
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return out_path.read_bytes()
+        except FileNotFoundError as e:
+            raise RuntimeError("FFmpeg not found. Install it and ensure 'ffmpeg' is on PATH.") from e
+        except subprocess.CalledProcessError:
+            # If conversion fails, try assuming it's already a readable WAV
+            return src_bytes
+
+def _transcribe_wav_bytes(wav_bytes: bytes) -> str:
+    """Write to disk (closed file) then transcribe. Avoids Windows file locking."""
+    td = tempfile.mkdtemp()
+    path = pathlib.Path(td) / "in.wav"
+    try:
+        path.write_bytes(wav_bytes)
+        segments, _ = asr.transcribe(str(path), beam_size=5, language="en")
+        return " ".join(s.text for s in segments).strip()
+    finally:
+        try:
+            path.unlink(missing_ok=True)
+        except Exception:
+            pass
+        try:
+            pathlib.Path(td).rmdir()
+        except Exception:
+            pass
+
+def audio_safe_from_bytes(raw_bytes: bytes) -> Dict:
+    wav = _ffmpeg_to_wav(raw_bytes)
+    text = _transcribe_wav_bytes(wav)
+    proba = text_clf.predict_proba([text])[0].tolist()
+    unsafe_p = float(proba[UNSAFE_ID])
+    return {
+        "safe": unsafe_p < 0.5,  # tune with AUDIO_UNSAFE_THR if you want parity
+        "unsafe_prob": unsafe_p,
+        "text": text,
+        "probs": proba,
+    }
+
+# ------------------------------ Routes ------------------------------
+@app.get("/health")
+def health():
+    return {
+        "ok": True,
+        "device": DEVICE,
+        "whisper": WHISPER_MODEL_NAME,
+        "img_unsafe_threshold": IMG_UNSAFE_THR,
+        "text_thresholds": {
+            "TEXT_UNSAFE_THR": TEXT_UNSAFE_THR,
+            "SHORT_MSG_MAX_TOKENS": SHORT_MSG_MAX_TOKENS,
+            "SHORT_MSG_UNSAFE_THR": SHORT_MSG_UNSAFE_THR,
+        },
+        "safe_unsafe_indices": {
+            "SAFE_ID": SAFE_ID,
+            "UNSAFE_ID": UNSAFE_ID,
+        }
+    }
+
+@app.post("/check_text")
+def check_text(text: str = Form(...)):
+    if not text or not text.strip():
+        raise HTTPException(400, "Empty text")
+    try:
+        return text_safe_payload(text)
+    except Exception as e:
+        raise HTTPException(500, f"Text screening error: {e}")
+
+@app.post("/check_image")
+async def check_image(file: UploadFile = File(...)):
+    data = await file.read()
+    if not data:
+        raise HTTPException(400, "Empty image")
+    try:
+        pil = Image.open(io.BytesIO(data))
+    except Exception:
+        raise HTTPException(400, "Invalid image")
+    try:
+        return image_safe_payload(pil)
+    except Exception as e:
+        raise HTTPException(500, f"Image screening error: {e}")
+
+@app.post("/check_audio")
+async def check_audio(file: UploadFile = File(...)):
+    raw = await file.read()
+    if not raw:
+        raise HTTPException(400, "Empty audio")
+    try:
+        return audio_safe_from_bytes(raw)
+    except RuntimeError as e:
+        print("AUDIO_ERR:", repr(e))
+        raise HTTPException(500, f"{e}")
+    except Exception as e:
+        print("AUDIO_ERR:", repr(e))
+        raise HTTPException(500, f"Audio processing error: {e}")
+
+# --------------------------- Static Mount ---------------------------
+# Serves your chat UI at "/" if STATIC_DIR.exists():
+if STATIC_DIR.exists():
+    app.mount("/", StaticFiles(directory=str(STATIC_DIR), html=True), name="static")

download_assets.py

@@ -0,0 +1,119 @@
+# download_assets.py — fetch models from a Google Drive FOLDER (no zips)
+# Expects a folder with subfolders: Text/, Image/, Audio/
+# Env: GDRIVE_FOLDER_ID=<your folder id>
+# Coder: Amir
+
+import os, sys, shutil, pathlib
+from typing import Optional
+from filelock import FileLock
+import gdown
+
+BASE = pathlib.Path(__file__).resolve().parent
+CACHE_DIR = BASE / "cache"
+DL_DIR = CACHE_DIR / "gdrive_folder"   # where we download the Drive folder
+
+TARGETS = {
+    "text": {
+        "dst": BASE / "Text",
+        "must": ["config.json", "tokenizer.json", "model.safetensors", "vocab.json"],
+        "folder_name": "Text",
+    },
+    "image": {
+        "dst": BASE / "Image",
+        "must": ["resnet_safety_classifier.pth", "clip_safety_classifier.pth"],
+        "folder_name": "Image",
+    },
+    "audio": {
+        "dst": BASE / "Audio",
+        "must": ["text_pipeline_balanced.joblib"],
+        "folder_name": "Audio",
+    },
+}
+
+def _ready(kind: str) -> bool:
+    info = TARGETS[kind]
+    d = info["dst"]
+    return d.exists() and all((d / m).exists() for m in info["must"])
+
+def _find_subdir(root: pathlib.Path, name: str) -> Optional[pathlib.Path]:
+    lname = name.lower()
+    for p in root.rglob("*"):
+        if p.is_dir() and p.name.lower() == lname:
+            return p
+    return None
+
+def _merge_copy(src: pathlib.Path, dst: pathlib.Path):
+    dst.mkdir(parents=True, exist_ok=True)
+    for root, dirs, files in os.walk(src):
+        rroot = pathlib.Path(root)
+        rel = rroot.relative_to(src)
+        # create subdirs
+        for d in dirs:
+            (dst / rel / d).mkdir(parents=True, exist_ok=True)
+        # copy files
+        for f in files:
+            s = rroot / f
+            t = dst / rel / f
+            t.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(s, t)
+
+def _download_folder(folder_id: str):
+    DL_DIR.mkdir(parents=True, exist_ok=True)
+    lock = FileLock(str(DL_DIR) + ".lock")
+    with lock:
+        # If already downloaded once, skip re-download
+        if any(DL_DIR.iterdir()):
+            print("[assets] Drive folder already present; skipping fresh download.")
+            return
+        print(f"[assets] downloading Drive folder {folder_id} …")
+        gdown.download_folder(
+            id=folder_id,
+            output=str(DL_DIR),
+            quiet=False,
+            use_cookies=False,
+            remaining_ok=True,
+        )
+
+def ensure_all_assets():
+    # If everything already exists, return fast
+    if all(_ready(k) for k in TARGETS):
+        print("[assets] all bundles already present.")
+        return
+
+    folder_id = os.getenv("GDRIVE_FOLDER_ID", "").strip()
+    if not folder_id:
+        raise RuntimeError("[assets] Please set GDRIVE_FOLDER_ID (top-level Drive folder with Text/Image/Audio)")
+
+    _download_folder(folder_id)
+
+    # Drive may nest one extra directory level; detect the top
+    # Pick the largest immediate subdir if needed, else use DL_DIR itself
+    root = DL_DIR
+    # If there is exactly one child dir and it contains our subfolders, use it
+    subdirs = [p for p in DL_DIR.iterdir() if p.is_dir()]
+    if len(subdirs) == 1:
+        maybe = subdirs[0]
+        if all(_find_subdir(maybe, TARGETS[k]["folder_name"]) for k in TARGETS):
+            root = maybe
+
+    # For each target, locate its folder and merge-copy into app dirs
+    for kind, info in TARGETS.items():
+        if _ready(kind):
+            print(f"[assets] {kind}: already ready.")
+            continue
+
+        src_dir = _find_subdir(root, info["folder_name"])
+        if not src_dir:
+            raise RuntimeError(f"[assets] {kind}: could not find '{info['folder_name']}' folder in Drive download")
+
+        print(f"[assets] {kind}: copying from {src_dir} → {info['dst']}")
+        _merge_copy(src_dir, info["dst"])
+
+        # sanity check
+        missing = [m for m in info["must"] if not (info["dst"] / m).exists()]
+        if missing:
+            raise RuntimeError(f"[assets] {kind}: missing files after copy → {missing}")
+
+        print(f"[assets] {kind}: ready.")
+
+    print("[assets] all bundles ready.")

index.html

@@ -1,19 +1,420 @@
-<!doctype html>
-<html>
-	<head>
-		<meta charset="utf-8" />
-		<meta name="viewport" content="width=device-width" />
-		<title>My static Space</title>
-		<link rel="stylesheet" href="style.css" />
-	</head>
-	<body>
-		<div class="card">
-			<h1>Welcome to your static Space!</h1>
-			<p>You can modify this app directly by editing <i>index.html</i> in the Files and versions tab.</p>
-			<p>
-				Also don't forget to check the
-				<a href="https://huggingface.co/docs/hub/spaces" target="_blank">Spaces documentation</a>.
-			</p>
-		</div>
-	</body>
-</html>
+<!doctype html>
+<html lang="en" data-bs-theme="light">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1,viewport-fit=cover" />
+  <title>BubbleGuard – Safe Chat</title>
+  <link rel="icon" href="/logo.png">
+  <!-- Bootstrap 5.3 -->
+  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet">
+  <!-- Apple-style theme -->
+  <link href="/styles.css" rel="stylesheet">
+</head>
+<body>
+  <div class="app">
+
+    <!-- Header -->
+    <header class="glass py-2 px-3">
+      <div class="container-fluid d-flex align-items-center gap-3">
+        <button class="btn btn-ico" type="button" aria-label="Back" title="Back">‹</button>
+        <div class="d-flex align-items-center gap-2">
+          <img src="/logo.png" alt="" class="rounded-3 header-logo" onerror="this.style.display='none'">
+          <div class="d-flex flex-column lh-1">
+            <div class="app-title">BubbleGuard</div>
+            <div id="health" class="subtle" aria-live="polite">Checking…</div>
+          </div>
+        </div>
+        <div class="ms-auto d-flex align-items-center gap-1">
+          <button id="theme" class="btn btn-ico" type="button" aria-label="Toggle theme" title="Appearance">🌓</button>
+        </div>
+      </div>
+    </header>
+
+    <!-- Chat -->
+    <main id="chat" class="container chat-wrap" aria-live="polite" aria-label="Chat history">
+      <!-- Greeting -->
+      <div class="row-start">
+        <img src="/avatar_female.png" alt="" class="avatar" onerror="this.style.display='none'">
+        <div class="bubble-them bubble shadow-bubble">
+          <div class="copy">Hey there 💖 Welcome to BubbleGuard’s safe chat! Share pics, voice notes, or messages — we’ll keep it kind.</div>
+          <div class="meta">now</div>
+        </div>
+      </div>
+    </main>
+
+    <!-- Composer -->
+    <footer class="composer-wrap">
+
+      <!-- Reply banner -->
+      <div id="replyBanner" class="reply-banner d-none" role="status" aria-live="polite">
+        <div class="rb-body">
+          <div class="rb-line">
+            <span class="rb-label">Replying to</span>
+            <span id="replySnippet" class="rb-snippet"></span>
+          </div>
+          <button id="replyCancel" class="btn-ico rb-close" aria-label="Cancel reply">✕</button>
+        </div>
+      </div>
+
+      <div class="container composer">
+        <input id="fileImg" type="file" accept="image/*" class="d-none" aria-hidden="true">
+
+        <button id="btnImg" class="btn btn-ico" title="Attach image" aria-label="Attach image">＋</button>
+
+        <div class="input-shell">
+          <!-- UPDATED placeholder text here -->
+          <textarea id="input" rows="1" placeholder="Write a message here…" class="form-control input-ios" aria-label="Message input"></textarea>
+          <div id="typing" class="typing d-none" aria-hidden="true">
+            <span class="typing-dot"></span><span class="typing-dot"></span><span class="typing-dot"></span>
+          </div>
+        </div>
+
+        <div class="audio-controls d-flex align-items-center gap-1">
+          <button id="btnStart" class="btn btn-ico" title="Record" aria-label="Start recording">🎤</button>
+          <button id="btnStop"  class="btn btn-ico" title="Stop"   aria-label="Stop recording" disabled>⏹</button>
+          <span id="recTimer" class="pill subtle d-none" aria-live="polite">00:00</span>
+        </div>
+
+        <button id="btnSend" class="btn send-ios" aria-label="Send">↑</button>
+      </div>
+
+      <!-- Toast -->
+      <div class="toast-zone">
+        <div id="toast" class="toast ios-toast" role="alert" aria-live="assertive" aria-atomic="true">
+          <div class="toast-body" id="toastBody">Hello</div>
+        </div>
+      </div>
+    </footer>
+  </div>
+
+  <!-- Bootstrap JS -->
+  <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js"></script>
+
+  <!-- App Script -->
+  <script>
+    // ---------- Config ----------
+    const baseURL = ''; // same-origin; set full origin if tunneling under a subpath
+    const api = (p) => baseURL + p;
+
+    // ---------- Theme ----------
+    const setTheme = (t)=> document.documentElement.setAttribute('data-bs-theme', t);
+    const saved = localStorage.getItem('bg-theme');
+    const prefersDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
+    setTheme(saved || (prefersDark ? 'dark' : 'light'));
+    document.getElementById('theme').onclick = () => {
+      const cur = document.documentElement.getAttribute('data-bs-theme');
+      const next = cur === 'dark' ? 'light' : 'dark';
+      setTheme(next); localStorage.setItem('bg-theme', next);
+    };
+
+    // ---------- Health ----------
+    (async () => {
+      try {
+        const r = await fetch(api('/health'));
+        if (!r.ok) throw 0;
+        const j = await r.json();
+        const t = j.text_thresholds || {};
+        const h = document.getElementById('health');
+        h.textContent = `Online · ${j.device} · T=${t.TEXT_UNSAFE_THR ?? '-'} · S=${t.SHORT_MSG_UNSAFE_THR ?? '-'}`;
+      } catch {
+        document.getElementById('health').textContent = 'Offline';
+      }
+    })();
+
+    // ---------- DOM helpers ----------
+    const $ = (id)=>document.getElementById(id);
+    const chat = $('chat'), input=$('input'), typing=$('typing');
+    const btnSend=$('btnSend'), btnImg=$('btnImg'), fileImg=$('fileImg');
+    const btnStart=$('btnStart'), btnStop=$('btnStop'), recTimer=$('recTimer');
+    const toastEl = $('toast'), toastBody = $('toastBody');
+    const toast = new bootstrap.Toast(toastEl, { delay: 4200 });
+
+    const timeNow = () => new Date().toLocaleTimeString([], {hour:'2-digit', minute:'2-digit'});
+    const scrollBottom = () => { chat.scrollTop = chat.scrollHeight; };
+    const showToast = (msg) => { toastBody.textContent = msg; toast.show(); };
+    const esc = (s)=>s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');
+
+    // ---------- Reactions & Reply state ----------
+    const REACTIONS = ["👍","❤️","😂","😮","😢"];
+    let replyTarget = null; // { el, text }
+
+    function markDelivered(bubble, double=false){
+      const meta = bubble.querySelector('.meta');
+      if(!meta) return;
+      let ticks = meta.querySelector('.ticks');
+      if(!ticks){
+        ticks = document.createElement('span');
+        ticks.className = 'ticks';
+        meta.appendChild(ticks);
+      }
+      ticks.innerHTML = double ? '<span class="tick-double"></span>' : '<span class="tick-solo"></span>';
+    }
+
+    function showReactionsPop(bubble){
+      hideReactionsPop();
+      const pop = document.createElement('div');
+      pop.className = 'react-pop';
+      pop.setAttribute('role','menu');
+      REACTIONS.forEach(e=>{
+        const b=document.createElement('button');
+        b.type='button'; b.textContent=e; b.setAttribute('aria-label',`React ${e}`);
+        b.onclick = (ev)=>{ ev.stopPropagation(); toggleReaction(bubble, e); hideReactionsPop(); };
+        pop.appendChild(b);
+      });
+      bubble.appendChild(pop);
+      setTimeout(()=>document.addEventListener('click', hideReactionsPop, { once:true }), 0);
+    }
+    function hideReactionsPop(){
+      document.querySelectorAll('.react-pop').forEach(p=>p.remove());
+    }
+
+    function toggleReaction(bubble, emoji){
+      bubble._reactions = bubble._reactions || new Map();
+      const meKey = `me:${emoji}`;
+      if(bubble._reactions.has(meKey)) bubble._reactions.delete(meKey);
+      else bubble._reactions.set(meKey, 1);
+      renderReactions(bubble);
+    }
+    function renderReactions(bubble){
+      const counts = {};
+      (bubble._reactions||new Map()).forEach((v,k)=>{
+        const em = k.split(':')[1];
+        counts[em] = (counts[em]||0) + 1;
+      });
+      let row = bubble.querySelector('.react-row');
+      if(!row){
+        row = document.createElement('div'); row.className='react-row';
+        bubble.appendChild(row);
+      }
+      row.innerHTML = '';
+      Object.entries(counts).sort((a,b)=>b[1]-a[1]).forEach(([em,c])=>{
+        const chip = document.createElement('span');
+        chip.className='react-chip';
+        chip.innerHTML = `${em} <span class="count">${c}</span>`;
+        row.appendChild(chip);
+      });
+      if(Object.keys(counts).length===0) row.remove();
+    }
+
+    function startReply(bubble){
+      const textNode = bubble.querySelector('.copy')?.textContent ?? '';
+      replyTarget = { el: bubble, text: textNode.trim().slice(0, 60) };
+      $('replySnippet').textContent = replyTarget.text || '(media)';
+      $('replyBanner').classList.remove('d-none');
+      bubble.classList.add('swipe-hint');
+      setTimeout(()=>bubble.classList.remove('swipe-hint'), 900);
+    }
+    function cancelReply(){
+      replyTarget = null;
+      $('replyBanner').classList.add('d-none');
+    }
+    $('replyCancel').onclick = cancelReply;
+
+    // ---------- Bubble creators ----------
+    function armBubbleInteractions(bubble, isThem=false){
+      // Reactions: long-press / right-click
+      let pressTimer = null;
+      const startPress = ()=>{ pressTimer=setTimeout(()=>showReactionsPop(bubble), 380); };
+      const endPress   = ()=>{ clearTimeout(pressTimer); };
+
+      bubble.addEventListener('contextmenu', (e)=>{ e.preventDefault(); showReactionsPop(bubble); });
+      bubble.addEventListener('pointerdown', startPress);
+      bubble.addEventListener('pointerup', endPress);
+      bubble.addEventListener('pointerleave', endPress);
+
+      // Swipe-to-reply on "them" bubbles (mobile)
+      if(isThem){
+        let sx=0, dx=0;
+        bubble.addEventListener('touchstart', (e)=>{ sx = e.touches[0].clientX; dx=0; }, {passive:true});
+        bubble.addEventListener('touchmove', (e)=>{
+          dx = e.touches[0].clientX - sx;
+          if(dx>12) bubble.style.transform = `translateX(${Math.min(dx, 72)}px)`;
+        }, {passive:true});
+        bubble.addEventListener('touchend', ()=>{
+          if(dx>56) startReply(bubble);
+          bubble.style.transform = '';
+        });
+      }
+    }
+
+    function bubbleMe(html) {
+      const row = document.createElement('div'); row.className='row-end';
+      row.innerHTML = `
+        <div class="bubble-you bubble shadow-bubble">
+          <div class="copy">${html}</div>
+          <div class="meta">${timeNow()}</div>
+        </div>
+        <img src="/avatar_male.png" alt="" class="avatar" onerror="this.style.display='none'">
+      `;
+      chat.appendChild(row); scrollBottom();
+      const b = row.querySelector('.bubble-you');
+      armBubbleInteractions(b, false);
+      setTimeout(()=>markDelivered(b, true), 450);
+      return b;
+    }
+
+    function bubbleThem(html) {
+      const row = document.createElement('div'); row.className='row-start';
+      row.innerHTML = `
+        <img src="/avatar_female.png" alt="" class="avatar" onerror="this.style.display='none'">
+        <div class="bubble-them bubble shadow-bubble">
+          <div class="copy">${html}</div>
+          <div class="meta">${timeNow()}</div>
+        </div>
+      `;
+      chat.appendChild(row); scrollBottom();
+      const b = row.querySelector('.bubble-them');
+      armBubbleInteractions(b, true);
+      return b;
+    }
+
+    // ---------- Blast helper (block animation) ----------
+    function blastBubble({ html, side='you', preview=true, icon='🚫', removeDelay=900 }){
+      const content = preview
+        ? `<span class="unsafe-icon" aria-hidden="true">${icon}</span><span class="unsafe-preview">${html}</span>`
+        : `<span class="unsafe-icon" aria-hidden="true">${icon}</span>`;
+      const bubble = side === 'you' ? bubbleMe(content) : bubbleThem(content);
+      bubble.classList.add('bubble-blast');
+      setTimeout(()=> bubble.closest('.row-start, .row-end')?.remove(), removeDelay);
+    }
+
+    // ---------- Input behavior ----------
+    function setTyping(on){ typing.classList.toggle('d-none', !on); }
+    input.addEventListener('input', ()=>{
+      input.style.height='auto';
+      input.style.height=Math.min(input.scrollHeight, 140)+'px';
+    });
+    input.addEventListener('keydown',(e)=>{
+      if(e.key==='Escape'){ input.value=''; input.style.height='auto'; }
+      if(e.key==='Enter' && !e.shiftKey){ e.preventDefault(); sendText(); }
+    });
+
+    // Normalize curly quotes/apostrophes BEFORE sending
+    function normalizeInputText(text){
+      return text.replace(/[’‘]/g, "'").replace(/[“”]/g, '"').replace(/\s+/g, ' ').trim();
+    }
+
+    // ---------- Send text ----------
+    async function sendText(){
+      let t = input.value;
+      t = normalizeInputText(t);
+      if(!t) return;
+
+      // If replying, prefix a quote (client-side only)
+      if(replyTarget){
+        const quoted = replyTarget.text ? `> ${replyTarget.text}\n` : '';
+        t = `${quoted}${t}`;
+      }
+
+      setTyping(true); btnSend.disabled=true;
+      try{
+        const fd = new FormData(); fd.append('text', t);
+        const r = await fetch(api('/check_text'),{method:'POST', body:fd});
+        const j = await r.json();
+
+        if (r.ok && j && typeof j.safe !== 'undefined') {
+          if (j.safe) {
+            bubbleMe(esc(t));
+            cancelReply();
+          } else {
+            blastBubble({ html: esc(t), side: 'you', preview: true, icon: '🚫' });
+            const reason = j.reason ? ` (${j.reason}${j.unsafe_prob!=null?` · p=${(+j.unsafe_prob).toFixed(2)}`:''})` : '';
+            showToast('Message blocked as unsafe' + reason);
+          }
+        } else {
+          showToast('Unexpected response');
+        }
+      }catch(e){ showToast('Error: '+e); }
+      finally{
+        input.value=''; input.style.height='auto';
+        setTyping(false); btnSend.disabled=false;
+      }
+    }
+    btnSend.onclick = sendText;
+
+    // ---------- Image: click & drag-drop ----------
+    btnImg.onclick = ()=> fileImg.click();
+    fileImg.onchange = async ()=>{ if(fileImg.files[0]) await handleImage(fileImg.files[0]); fileImg.value=''; };
+
+    async function handleImage(file){
+      setTyping(true);
+      try{
+        const fd = new FormData(); fd.append('file', file);
+        const r = await fetch(api('/check_image'),{method:'POST', body:fd});
+        const j = await r.json();
+        if(j.safe){
+          const url = URL.createObjectURL(file);
+          bubbleMe(`<img src="${url}" class="chat-image" alt="Sent image">`);
+        } else {
+          blastBubble({ html: 'Image blocked', side: 'you', preview: false, icon: '🖼️' });
+          const reason = j.unsafe_prob!=null?` (p=${(+j.unsafe_prob).toFixed(2)})`:''; showToast('Image blocked as unsafe' + reason);
+        }
+      }catch(e){ showToast('Error: '+e); }
+      finally{ setTyping(false); }
+    }
+
+    // Drag & Drop (image only)
+    ['dragenter','dragover'].forEach(ev=>document.addEventListener(ev, e=>{ e.preventDefault(); chat.classList.add('drop'); }, false));
+    ;['dragleave','drop'].forEach(ev=>document.addEventListener(ev, e=>{ e.preventDefault(); chat.classList.remove('drop'); }, false));
+    document.addEventListener('drop', async (e)=>{
+      const f = e.dataTransfer?.files?.[0];
+      if(!f) return;
+      if (f.type.startsWith('image/')) await handleImage(f);
+      else showToast('Only images supported via drop.');
+    }, false);
+
+    // ---------- Voice ----------
+    let mediaStream=null, mediaRecorder=null, chunks=[], tick=null, startTs=0;
+    const pickMime = () => {
+      const prefs=['audio/webm;codecs=opus','audio/webm','audio/mp4;codecs=mp4a.40.2','audio/mp4','audio/ogg;codecs=opus','audio/ogg'];
+      for(const m of prefs) if (window.MediaRecorder && MediaRecorder.isTypeSupported(m)) return m;
+      return '';
+    };
+    async function ensureMic(){ if(!mediaStream) mediaStream = await navigator.mediaDevices.getUserMedia({audio:true}); }
+    function setRecUI(recording){
+      btnStart.disabled=recording; btnStop.disabled=!recording;
+      recTimer.classList.toggle('d-none',!recording);
+    }
+    const fmt = (t)=>{ const m=Math.floor(t/60), s=Math.floor(t%60); return `${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')}`; };
+
+    btnStart.onclick = async ()=>{
+      try{
+        await ensureMic(); chunks=[];
+        const mime = pickMime();
+        mediaRecorder = new MediaRecorder(mediaStream, mime? {mimeType:mime}:{});
+        mediaRecorder.ondataavailable = e => { if(e.data && e.data.size) chunks.push(e.data); };
+        mediaRecorder.onstop = onRecordingStop;
+        mediaRecorder.start(250);
+        startTs = Date.now();
+        tick = setInterval(()=> recTimer.textContent = fmt((Date.now()-startTs)/1000), 300);
+        setRecUI(true);
+        setTimeout(()=>{ if(mediaRecorder && mediaRecorder.state==='recording') btnStop.click(); }, 60000);
+      }catch(e){ showToast('Mic error: '+e); }
+    };
+    btnStop.onclick = ()=>{
+      if(mediaRecorder && mediaRecorder.state==='recording'){ mediaRecorder.stop(); }
+      if(tick){ clearInterval(tick); tick=null; }
+      setRecUI(false);
+    };
+
+    async function onRecordingStop(){
+      try{
+        setTyping(true);
+        const type = mediaRecorder?.mimeType || 'audio/webm';
+        const blob = new Blob(chunks, { type });
+        const fd = new FormData(); fd.append('file', blob, 'voice');
+        const r = await fetch(api('/check_audio'), { method:'POST', body: fd });
+        const j = await r.json();
+        if(j.safe){
+          const url = URL.createObjectURL(blob);
+          bubbleMe(`<audio controls src="${url}" class="audio-ios"></audio>`);
+        }else{
+          blastBubble({ html: 'Voice note blocked', side: 'you', preview: false, icon: '🔊' });
+          const reason = j.unsafe_prob!=null?` (p=${(+j.unsafe_prob).toFixed(2)})`:''; showToast('Voice note blocked as unsafe' + reason);
+        }
+      }catch(e){ showToast('Error: '+e); }
+      finally{ setTyping(false); }
+    }
+  </script>
+</body>
+</html>

main.py

@@ -0,0 +1,59 @@
+# main.py — ASGI entrypoint for BubbleGuard Web (HF-ready, with GDrive fetch)
+# Coder: Amir
+# ------------------------------------------------
+# - Downloads model bundles from Google Drive (via download_assets.py)
+# - Starts Uvicorn serving app_server:app
+# - Respects HOST/PORT env (PORT is injected by Hugging Face Spaces)
+
+import os
+import sys
+import traceback
+
+def _truthy(val: str) -> bool:
+    return str(val).strip().lower() in {"1", "true", "yes", "on"}
+
+def main() -> None:
+    # --- Env & logging setup ---
+    host = os.getenv("HOST", "0.0.0.0")
+    port = int(os.getenv("PORT", "8000"))
+    debug = _truthy(os.getenv("DEBUG", "0"))
+
+    print(f"[BubbleGuard] Starting server on {host}:{port}")
+    folder_id = os.getenv("GDRIVE_FOLDER_ID", "").strip()
+    if folder_id:
+        print(f"[BubbleGuard] Using Google Drive folder: {folder_id}")
+    else:
+        print("[BubbleGuard] No GDRIVE_FOLDER_ID set (will try per-file IDs if provided).")
+
+    # --- Ensure assets (idempotent) before importing the app ---
+    try:
+        from download_assets import ensure_all_assets
+        ensure_all_assets()
+    except Exception as e:
+        print("[BubbleGuard] ERROR while preparing assets:", file=sys.stderr)
+        traceback.print_exc()
+        raise SystemExit(1)
+
+    # --- Run Uvicorn ---
+    try:
+        import uvicorn
+        # Use string import so app is imported after assets are ready
+        uvicorn.run(
+            "app_server:app",
+            host=host,
+            port=port,
+            reload=False,                 # safer with large models
+            workers=1,                    # avoid duplicating model memory
+            log_level="debug" if debug else "info",
+            proxy_headers=True,           # play nice behind proxies (HF Spaces)
+            forwarded_allow_ips="*",
+            timeout_keep_alive=10,
+            access_log=True,
+        )
+    except Exception:
+        print("[BubbleGuard] Uvicorn failed to start:", file=sys.stderr)
+        traceback.print_exc()
+        raise SystemExit(1)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,25 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+
+fastapi==0.112.2
+uvicorn[standard]==0.30.6
+python-multipart==0.0.9
+
+torch==2.3.1+cpu
+torchvision==0.18.1+cpu
+torchaudio==2.3.1+cpu
+
+transformers==4.43.4
+accelerate==0.33.0
+huggingface-hub==0.24.5
+safetensors==0.4.3
+
+numpy==1.26.4
+Pillow==10.4.0
+joblib==1.4.2
+
+faster-whisper==1.0.3
+soundfile==0.12.1
+
+gdown==5.2.0
+tqdm==4.66.4
+filelock==3.15.4

styles.css

@@ -0,0 +1,379 @@
+/* =========================
+   BubbleGuard Apple-Style UI
+   Dark-mode optimized (2025)
+   ========================= */
+
+/* ---------- Design Tokens ---------- */
+:root{
+  /* Typography */
+  --font-ui: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, "Apple Color Emoji", "Segoe UI Emoji";
+
+  /* Light palette */
+  --bg: #f5f5f7;
+  --bg-radial-1: #ffffff;
+  --bg-radial-2: rgba(10,132,255,.08);
+  --sheet: #ffffffcc;           /* frosted surfaces */
+  --border: #e5e5ea;
+  --text: #111114;
+  --muted: #6e6e73;
+
+  /* Bubbles */
+  --blue: #0A84FF;              /* outgoing */
+  --blue-press: #0a7af0;
+  --incoming: #E5E5EA;          /* incoming */
+  --incoming-text: #000;
+
+  /* Accents */
+  --focus: rgba(10,132,255,.5);
+  --focus-outer: rgba(10,132,255,.15);
+
+  /* Shadows */
+  --shadow: 0 6px 24px rgba(0,0,0,.06);
+  --shadow-strong: 0 10px 28px rgba(0,0,0,.10);
+
+  /* Overlays/Pop */
+  --popover-bg: rgba(28,28,30,.96);
+  --chip-bg: rgba(118,118,128,.18);
+
+  /* Misc */
+  --danger: #ff3b30;
+
+  /* Timestamp color (light mode) */
+  --meta-color: #000;
+}
+
+[data-bs-theme="dark"]{
+  /* Dark palette tuned for contrast */
+  --bg: #0b0b0f;
+  --bg-radial-1: #121217;
+  --bg-radial-2: rgba(10,132,255,.10);
+  --sheet: rgba(22,22,26,.76);
+  --border: #2a2a31;
+  --text: #ececf2;
+  --muted: #a1a1aa;
+
+  /* Bubbles */
+  --blue: #0A84FF;
+  --blue-press: #0a74e0;
+  --incoming: #1f1f24;          /* deeper slate for dark */
+  --incoming-text: #ececf2;
+
+  /* Accents */
+  --focus: rgba(10,132,255,.6);
+  --focus-outer: rgba(10,132,255,.22);
+
+  /* Shadows (softer/lower spread in dark to avoid haze) */
+  --shadow: 0 8px 24px rgba(0,0,0,.45);
+  --shadow-strong: 0 12px 36px rgba(0,0,0,.55);
+
+  --popover-bg: rgba(18,18,20,.98);
+  --chip-bg: rgba(255,255,255,.08);
+
+  /* Timestamp color (dark mode) */
+  --meta-color: #fff;
+}
+
+/* ---------- Base Layout ---------- */
+html, body { height:100%; }
+body{
+  font-family: var(--font-ui);
+  background:
+    radial-gradient(900px 360px at 80% -10%, var(--bg-radial-1), transparent 60%),
+    radial-gradient(900px 360px at -10% 110%, var(--bg-radial-2), transparent 70%),
+    var(--bg);
+  color: var(--text);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+/* Smooth theme transitions (respect reduced motion) */
+@media (prefers-reduced-motion: no-preference){
+  body, .glass, .composer-wrap, .bubble, .input-ios, .ios-toast {
+    transition: background-color .25s ease, color .25s ease, border-color .25s ease, box-shadow .25s ease;
+  }
+}
+
+.app{ height:100dvh; display:grid; grid-template-rows:auto 1fr auto; }
+
+/* ---------- Header ---------- */
+.glass{
+  backdrop-filter: saturate(1.15) blur(14px);
+  background: var(--sheet);
+  border-bottom: 1px solid var(--border);
+}
+.header-logo{ width:28px; height:28px; border-radius:8px; }
+.app-title{ font-weight:600; letter-spacing:.2px; }
+.subtle{ color: var(--muted); font-size:.82rem; }
+
+/* Icon buttons (header + composer) */
+.btn-ico{
+  border: none;
+  background: transparent;
+  font-size: 20px;
+  line-height: 1;
+  padding: .35rem .5rem;
+  border-radius: 10px;
+  color: inherit;
+}
+.btn-ico:hover{ background: color-mix(in oklab, var(--border), transparent 70%); }
+.btn-ico:focus-visible{ outline: 2px solid var(--focus); outline-offset: 2px; }
+
+/* ---------- Chat Area ---------- */
+.container.chat-wrap{ padding: 14px 14px 8px; overflow:auto; }
+.row-start, .row-end{
+  display:flex; gap:.6rem; align-items:flex-end; margin-bottom: .5rem;
+}
+.row-end{ justify-content: flex-end; }
+.avatar{ width:28px; height:28px; border-radius:50%; flex:0 0 28px; }
+
+/* ---------- Bubbles ---------- */
+.bubble{
+  max-width: 76%;
+  border-radius: 20px;
+  padding: 8px 12px;
+  position: relative;
+  box-shadow: var(--shadow);
+  word-wrap: break-word;
+
+  /* New message pop-in animation */
+  animation: pop .28s ease-out both;
+  animation-delay: var(--bubble-delay, 0s);
+}
+.bubble .copy{ font-size: .98rem; line-height: 1.25rem; }
+
+/* timestamp uses theme token for color */
+.bubble .meta{
+  font-size: .72rem;
+  color: var(--meta-color);
+  margin-top: 2px;
+  text-align: right;
+}
+
+.bubble-you{
+  background: var(--blue);
+  color: #fff;
+  border-bottom-right-radius: 6px; /* iMessage corner */
+  /* Outgoing bubbles lift slightly as they appear */
+  animation-name: popYou, pop; /* first run popYou (translate), pop already set for scale */
+}
+@keyframes popYou{
+  0%   { transform: translateY(6px) scale(.94); opacity:0; }
+  70%  { transform: translateY(0) scale(1.04); opacity:1; }
+  100% { transform: translateY(0) scale(1); }
+}
+
+.bubble-them{
+  background: var(--incoming);
+  color: var(--incoming-text);
+  border-bottom-left-radius: 6px;
+}
+
+/* Bubble tails */
+.bubble-you::after, .bubble-them::after{
+  content:""; position:absolute; bottom:0; width:10px; height:14px; background:transparent;
+}
+.bubble-you::after{
+  right:-2px; border-bottom-right-radius: 4px;
+  box-shadow: 2px 2px 0 0 var(--blue);
+}
+.bubble-them::after{
+  left:-2px; border-bottom-left-radius: 4px;
+  box-shadow: -2px 2px 0 0 var(--incoming);
+}
+
+/* Media inside bubbles */
+.chat-image{
+  max-width: 260px; border-radius: 14px; display:block; box-shadow: var(--shadow-strong);
+  animation: pop .28s ease-out both;
+}
+.audio-ios{ width: 260px; }
+
+/* ---------- Composer ---------- */
+.composer-wrap{
+  backdrop-filter: blur(18px) saturate(1.1);
+  border-top: 1px solid var(--border);
+  background: var(--sheet);
+}
+.composer{
+  display:grid; grid-template-columns: auto 1fr auto auto auto;
+  gap: .5rem; align-items:center; padding: .6rem 0;
+}
+
+.input-shell{ position: relative; display:flex; align-items:center; width:100%; }
+.input-ios{
+  background: color-mix(in oklab, var(--incoming), transparent 75%);
+  border: 1px solid color-mix(in oklab, var(--border), transparent 20%);
+  color: var(--text);
+  border-radius: 18px;
+  padding: .55rem 2.8rem .55rem .8rem;
+  box-shadow: none; resize: none; width:100%;
+  caret-color: var(--blue);
+}
+.input-ios::placeholder{ color: color-mix(in oklab, var(--muted), #000 0%); opacity:.8; }
+[data-bs-theme="dark"] .input-ios::placeholder{ color: color-mix(in oklab, var(--muted), #fff 8%); opacity:.85; }
+
+.input-ios:focus{
+  border-color: color-mix(in oklab, var(--blue), var(--border) 55%);
+  outline: none;
+  box-shadow: 0 0 0 .22rem var(--focus-outer);
+}
+
+/* typing indicator inside input — now bouncing */
+.typing{ position:absolute; right:.8rem; top:50%; transform: translateY(-50%); }
+.typing-dot{
+  width:6px;height:6px;border-radius:999px;display:inline-block;background: color-mix(in oklab, var(--muted), #9aa0a6 15%);
+  animation: bounceDot 1s infinite ease-in-out;
+}
+.typing-dot:nth-child(2){animation-delay:.16s}
+.typing-dot:nth-child(3){animation-delay:.32s}
+
+/* Send button */
+.send-ios{
+  background: var(--blue);
+  border: none;
+  color: #fff;
+  width: 36px; height: 36px; border-radius: 50%;
+  display:inline-flex; align-items:center; justify-content:center;
+  font-weight:600; font-size: 16px;
+  box-shadow: 0 6px 18px color-mix(in oklab, var(--blue), transparent 65%);
+}
+/* click pulse feedback */
+.send-ios:active{ background: var(--blue-press); animation: pulse .4s ease; }
+.send-ios:focus-visible{ outline: 2px solid var(--focus); outline-offset: 2px; }
+
+/* ---------- Toast (iOS banner style) ---------- */
+.toast-zone{ position: fixed; bottom: 16px; right: 16px; z-index: 1080; }
+.ios-toast{
+  background: var(--popover-bg);
+  color: #fff;
+  border: 0;
+  border-radius: 14px;
+  box-shadow: var(--shadow);
+  animation: toastSlide .3s ease both;
+}
+.ios-toast .toast-body{ padding: .6rem .8rem; }
+
+/* ---------- Drag & Drop highlight ---------- */
+.drop{
+  outline: 2px dashed color-mix(in oklab, var(--blue), #fff 0%);
+  outline-offset: 6px;
+  border-radius: 12px;
+}
+
+/* ---------- Block “blast” effect ---------- */
+.bubble-blast{
+  animation: popout .4s ease forwards;
+  filter: saturate(1.1);
+  background-image: linear-gradient(0deg, rgba(255,255,255,.08), transparent);
+}
+
+/* ---------- Extras: ticks, reactions, reply banner ---------- */
+/* Delivered ticks */
+.meta .ticks { margin-left:.35rem; display:inline-flex; gap:2px; vertical-align:baseline; }
+.tick-solo, .tick-double { font-size:.72rem; opacity:.8; color: currentColor; }
+.tick-double::after { content:"✓✓"; letter-spacing:-2px; }
+.tick-solo::after  { content:"✓"; }
+
+/* Reactions popover */
+.react-pop{
+  position:absolute; bottom:calc(100% + 6px); left:50%; transform:translateX(-50%);
+  background: var(--popover-bg); color:#fff; border-radius:999px; padding:.25rem .35rem;
+  display:flex; gap:.15rem; box-shadow: var(--shadow); z-index: 20; user-select:none;
+  animation: popMenu .16s ease-out both;
+}
+.react-pop button{
+  background:transparent; border:0; font-size:1rem; line-height:1; padding:.25rem .35rem; border-radius:10px; color:#fff;
+}
+.react-pop button:focus-visible{ outline:2px solid rgba(255,255,255,.35); outline-offset:2px; }
+
+/* Reaction badges under bubble */
+.react-row{
+  display:flex; gap:.25rem; margin-top:.25rem; flex-wrap:wrap;
+}
+.react-chip{
+  background: var(--chip-bg); color: var(--text);
+  border-radius: 999px; padding:.05rem .45rem; font-size:.75rem; display:inline-flex; gap:.25rem; align-items:center;
+  border: 1px solid var(--border);
+  animation: reactionPop .24s ease-out both;
+}
+
+/* Reply banner */
+.reply-banner{
+  border-bottom:1px solid var(--border);
+  background: color-mix(in oklab, var(--sheet), transparent 0%);
+}
+.reply-banner .rb-body{
+  padding:.35rem .75rem; display:flex; align-items:center; gap:.75rem; max-width: 980px; margin: 0 auto;
+}
+.rb-line{ flex:1; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+.rb-label{ color: var(--muted); margin-right:.35rem; }
+.rb-snippet{ color: var(--text); opacity:.95; }
+.rb-close{ margin-left:auto; }
+
+/* Swipe hint (subtle blue outline pulse) */
+@keyframes hintPulse{
+  0%{ box-shadow: 0 0 0 0 color-mix(in oklab, var(--blue), transparent 75%); }
+  100%{ box-shadow: 0 0 0 10px transparent; }
+}
+.bubble-them.swipe-hint{ animation: hintPulse .9s ease-out 1; }
+
+/* Ensure bubbles anchor popovers */
+.bubble { position: relative; }
+
+/* ---------- Animations ---------- */
+@keyframes pop{
+  0%   { transform: scale(.88); opacity: 0; }
+  70%  { transform: scale(1.04); opacity: 1; }
+  100% { transform: scale(1); }
+}
+@keyframes popout{
+  0%{ transform: scale(1); opacity:1 }
+  70%{ transform: scale(1.04); opacity:.75 }
+  100%{ transform: scale(.82); opacity:0 }
+}
+@keyframes bounceDot{
+  0%, 80%, 100% { transform: translateY(0); }
+  40% { transform: translateY(-4px); }
+}
+@keyframes pulse{
+  0%   { transform: scale(1); box-shadow: 0 0 0 0 rgba(10,132,255,.5); }
+  70%  { transform: scale(1.05); box-shadow: 0 0 0 8px rgba(10,132,255,0); }
+  100% { transform: scale(1); box-shadow: 0 0 0 0 rgba(10,132,255,0); }
+}
+@keyframes popMenu{
+  0% { transform: translateX(-50%) scale(.86); opacity:0; }
+  100%{ transform: translateX(-50%) scale(1);   opacity:1; }
+}
+@keyframes reactionPop{
+  0% { transform: scale(.75); opacity:0; }
+  70%{ transform: scale(1.12); opacity:1; }
+  100%{ transform: scale(1); }
+}
+@keyframes toastSlide{
+  0% { transform: translateY(16px); opacity:0; }
+  100%{ transform: translateY(0);    opacity:1; }
+}
+
+/* ---------- Accessibility & Polish ---------- */
+/* Visible selection & caret */
+::selection{ background: color-mix(in oklab, var(--blue), #ffffff 20%); color:#fff; }
+
+/* High-contrast focus outlines on anchors/controls */
+a:focus-visible, button:focus-visible, textarea:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; }
+
+/* Scrollbar (subtle, both themes) */
+*{ scrollbar-width: thin; scrollbar-color: color-mix(in oklab, var(--muted), #000 0%) transparent; }
+::-webkit-scrollbar{ height:10px; width:10px; }
+::-webkit-scrollbar-thumb{ background: color-mix(in oklab, var(--muted), transparent 60%); border-radius: 10px; }
+::-webkit-scrollbar-track{ background: transparent; }
+
+/* Reduced motion */
+@media (prefers-reduced-motion: reduce){
+  *{ animation: none !important; transition: none !important; }
+}
+
+/* ---------- Small-screen tweaks ---------- */
+@media (max-width: 460px){
+  .bubble{ max-width: 84%; }
+  .chat-image, .audio-ios{ max-width: 220px; }
+}