Delete unused/old files

app.py

@@ -1,9 +0,0 @@
-"""
-Entry point for Hugging Face Spaces
-"""
-import uvicorn
-# This imports the 'app' from your new modular folder structure
-from mrrrme.backend.app import app
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=8000)

model/AU_model.py

@@ -1,112 +0,0 @@
-import torch
-import torch.nn as nn
-import numpy as np
-import torch.nn.functional as F
-import math
-
-def normalize_digraph(A):
-    b, n, _ = A.shape
-    node_degrees = A.detach().sum(dim = -1)
-    degs_inv_sqrt = node_degrees ** -0.5
-    norm_degs_matrix = torch.eye(n)
-    dev = A.get_device()
-    if dev >= 0:
-        norm_degs_matrix = norm_degs_matrix.to(dev)
-    norm_degs_matrix = norm_degs_matrix.view(1, n, n) * degs_inv_sqrt.view(b, n, 1)
-    norm_A = torch.bmm(torch.bmm(norm_degs_matrix,A),norm_degs_matrix)
-    return norm_A
-
-
-class GNN(nn.Module):
-    def __init__(self, in_channels, num_classes, neighbor_num=4, metric='dots'):
-        super(GNN, self).__init__()
-        # in_channels: dim of node feature
-        # num_classes: num of nodes
-        # neighbor_num: K in paper and we select the top-K nearest neighbors for each node feature.
-        # metric: metric for assessing node similarity. Used in FGG module to build a dynamical graph
-        # X' = ReLU(X + BN(V(X) + A x U(X)) )
-
-        self.in_channels = in_channels
-        self.num_classes = num_classes
-        self.relu = nn.ReLU()
-        self.metric = metric
-        self.neighbor_num = neighbor_num
-
-        # network
-        self.U = nn.Linear(self.in_channels,self.in_channels)
-        self.V = nn.Linear(self.in_channels,self.in_channels)
-        self.bnv = nn.BatchNorm1d(num_classes)
-
-        # init
-        self.U.weight.data.normal_(0, math.sqrt(2. / self.in_channels))
-        self.V.weight.data.normal_(0, math.sqrt(2. / self.in_channels))
-        self.bnv.weight.data.fill_(1)
-        self.bnv.bias.data.zero_()
-
-    def forward(self, x):
-        b, n, c = x.shape
-
-        # build dynamical graph
-        if self.metric == 'dots':
-            si = x.detach()
-            si = torch.einsum('b i j , b j k -> b i k', si, si.transpose(1, 2))
-            threshold = si.topk(k=self.neighbor_num, dim=-1, largest=True)[0][:, :, -1].view(b, n, 1)
-            adj = (si >= threshold).float()
-
-        elif self.metric == 'cosine':
-            si = x.detach()
-            si = F.normalize(si, p=2, dim=-1)
-            si = torch.einsum('b i j , b j k -> b i k', si, si.transpose(1, 2))
-            threshold = si.topk(k=self.neighbor_num, dim=-1, largest=True)[0][:, :, -1].view(b, n, 1)
-            adj = (si >= threshold).float()
-
-        elif self.metric == 'l1':
-            si = x.detach().repeat(1, n, 1).view(b, n, n, c)
-            si = torch.abs(si.transpose(1, 2) - si)
-            si = si.sum(dim=-1)
-            threshold = si.topk(k=self.neighbor_num, dim=-1, largest=False)[0][:, :, -1].view(b, n, 1)
-            adj = (si <= threshold).float()
-
-        else:
-            raise Exception("Error: wrong metric: ", self.metric)
-
-        # GNN process
-        A = normalize_digraph(adj)
-        aggregate = torch.einsum('b i j, b j k->b i k', A, self.V(x))
-        x = self.relu(x + self.bnv(aggregate + self.U(x)))
-        return x
-
-
-class Head(nn.Module):
-    def __init__(self, in_channels, num_classes, neighbor_num=4, metric='dots'):
-        super(Head, self).__init__()
-        self.in_channels = in_channels
-        self.num_classes = num_classes
-        class_linear_layers = []
-        for i in range(self.num_classes):
-            layer = nn.Linear(self.in_channels, self.in_channels)
-            class_linear_layers += [layer]
-        self.class_linears = nn.ModuleList(class_linear_layers)
-        self.gnn = GNN(self.in_channels, self.num_classes,neighbor_num=neighbor_num,metric=metric)
-        self.sc = nn.Parameter(torch.FloatTensor(torch.zeros(self.num_classes, self.in_channels)))
-        self.relu = nn.ReLU()
-
-        nn.init.xavier_uniform_(self.sc)
-
-    def forward(self, x):
-        # AFG
-        f_u = []
-        for i, layer in enumerate(self.class_linears):
-            f_u.append(layer(x).unsqueeze(1))
-        f_u = torch.cat(f_u, dim=1)
-        # f_v = f_u.mean(dim=-2)
-        # FGG
-        f_v = self.gnn(f_u)
-        # f_v = self.gnn(f_v)
-        b, n, c = f_v.shape
-        sc = self.sc
-        sc = self.relu(sc)
-        sc = F.normalize(sc, p=2, dim=-1)
-        cl = F.normalize(f_v, p=2, dim=-1)
-        cl = (cl * sc.view(1, n, c)).sum(dim=-1)
-        return cl

model/AutomaticWeightedLoss.py

@@ -1,31 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import torch
-import torch.nn as nn
-
-class AutomaticWeightedLoss(nn.Module):
-    """automatically weighted multi-task loss
-
-    Params：
-        num: int，the number of loss
-        x: multi-task loss
-    Examples：
-        loss1=1
-        loss2=2
-        awl = AutomaticWeightedLoss(2)
-        loss_sum = awl(loss1, loss2)
-    """
-    def __init__(self, num=2):
-        super(AutomaticWeightedLoss, self).__init__()
-        params = torch.ones(num, requires_grad=True)
-        self.params = torch.nn.Parameter(params)
-
-    def forward(self, *x):
-        loss_sum = 0
-        for i, loss in enumerate(x):
-            loss_sum += 0.5 / (self.params[i] ** 2) * loss + torch.log(1 + self.params[i] ** 2)
-        return loss_sum
-
-if __name__ == '__main__':
-    awl = AutomaticWeightedLoss(2)
-    print(awl.parameters())

model/MLT.py

@@ -1,38 +0,0 @@
-import torch
-import torch.nn as nn
-import timm
-
-from .AU_model import *
-
-class MLT(nn.Module):
-    def __init__(self, base_model_name='tf_efficientnet_b0_ns', expr_classes=8, au_numbers=8):
-        super(MLT, self).__init__()
-        self.base_model = timm.create_model(base_model_name, pretrained=False)
-        self.base_model.classifier = nn.Identity()
-        
-        feature_dim = self.base_model.num_features
-
-        self.relu = nn.ReLU()
-
-        self.fc_emotion = nn.Linear(feature_dim, feature_dim)
-        self.fc_gaze = nn.Linear(feature_dim, feature_dim)
-        self.fc_au = nn.Linear(feature_dim, feature_dim)
-        
-        self.emotion_classifier = nn.Linear(feature_dim, expr_classes)
-        self.gaze_regressor = nn.Linear(feature_dim, 2)  
-        # self.au_regressor = nn.Linear(feature_dim, au_numbers)  
-        self.au_regressor = Head(in_channels=feature_dim, num_classes=au_numbers, neighbor_num=4, metric='dots')
-
-    def forward(self, x):
-        features = self.base_model(x)
-
-        features_emotion = self.relu(self.fc_emotion(features))
-        features_gaze = self.relu(self.fc_gaze(features))
-        features_au = self.relu(self.fc_au(features))
-        
-        emotion_output = self.emotion_classifier(features_emotion)
-        gaze_output = self.gaze_regressor(features_gaze)
-        # au_output = torch.sigmoid(self.au_regressor(features_au))
-        au_output = self.au_regressor(features_au)
-        
-        return emotion_output, gaze_output, au_output

mrrrme/audio/voice_assistant.py

@@ -1,227 +0,0 @@
-"""Text-to-Speech using Coqui XTTS v2 (Multi-lingual)"""
-import os
-import time
-import tempfile
-import threading
-import pygame
-import torch
-import numpy as np
-from dotenv import load_dotenv
-from TTS.api import TTS  # Coqui TTS
-
-load_dotenv()
-
-# XTTS v2 Default Speakers
-# Replaced "Andrew Chipper" with "Damien Black" (Confirmed Male)
-VOICE_MAP = {
-    "female": "Ana Florence",
-    "male": "Damien Black",
-    "Happy": "Ana Florence",
-    "Sad": "Ana Florence",
-    "Angry": "Damien Black",
-    "Neutral": "Ana Florence",
-}
-
-class VoiceAssistant:
-    """Coqui XTTS v2 TTS"""
-
-    def __init__(self, voice: str = "female", rate: float = 1.0, language: str = "en"):
-        self.voice_key = voice
-        self.voice_name = VOICE_MAP.get(voice, "Ana Florence")
-        self.rate = rate
-        self.language = language
-        
-        self.counter = 0
-        self.is_speaking = False
-        self.speaking_lock = threading.Lock()
-        self.audio_workers = []
-        
-        print(f"[TTS] 🚀 Initializing Coqui XTTS v2...")
-        
-        # Initialize Coqui TTS with XTTS v2 model
-        # gpu=True will use CUDA if available
-        try:
-            device = "cuda" if torch.cuda.is_available() else "cpu"
-            print(f"[TTS] 📥 Loading XTTS v2 model on {device} (this may take time on first run)...")
-            
-            self.tts = TTS("tts_models/multilingual/multi-dataset/xtts_v2").to(device)
-            
-            print(f"[TTS] ✅ XTTS v2 model loaded")
-        except Exception as e:
-            print(f"[TTS] ⚠️ XTTS init error: {e}")
-            self.tts = None
-
-        print("[TTS] 🔧 Initializing pygame...")
-        try:
-            pygame.mixer.quit()
-            pygame.mixer.init(frequency=24000, size=-16, channels=1, buffer=2048)
-            print(f"[TTS] ✅ Pygame ready")
-        except Exception as e:
-            print(f"[TTS] ⚠️ Pygame warning: {e}")
-
-        print(f"[TTS] ✅ Ready ({self.voice_name}, {language})\n")
-
-    def register_audio_worker(self, worker):
-        self.audio_workers.append(worker)
-        print(f"[TTS] ✅ Registered: {worker.__class__.__name__}")
-
-    def set_voice(self, voice_key: str):
-        """Switch between male/female voices"""
-        if voice_key in VOICE_MAP:
-            self.voice_name = VOICE_MAP[voice_key]
-            self.voice_key = voice_key
-            print(f"[TTS] 🎙️ Voice → {self.voice_name}")
-        else:
-            # If user passes a raw speaker name that exists in XTTS
-            self.voice_name = voice_key
-            print(f"[TTS] 🎙️ Voice → {self.voice_name} (Custom)")
-
-    def set_language(self, language: str):
-        """Set language (e.g., 'en', 'nl')"""
-        self.language = language
-        print(f"[TTS] 🌍 Language → {language}")
-
-    def set_rate(self, rate: float):
-        """
-        Note: XTTS v2 does not natively support speed control via API in the same way.
-        This is kept for compatibility but might not affect generation speed directly.
-        """
-        self.rate = max(0.5, min(2.0, rate))
-        print(f"[TTS] 🎚️ Rate → {self.rate}x (XTTS may ignore this)")
-
-    def apply_emotion_voice(self, emotion: str, intensity: float = 0.5):
-        """
-        Adjusts internal state based on emotion.
-        Note: XTTS implies emotion via the input text or style transfer (if enabled).
-        For now, we just log it or adjust simple parameters.
-        """
-        if emotion == "Happy":
-            self.rate = 1.1
-        elif emotion == "Sad":
-            self.rate = 0.9
-        elif emotion == "Angry":
-            self.rate = 1.2
-        else:
-            self.rate = 1.0
-
-    def stop(self):
-        print("[TTS] 🛑 STOP")
-        try:
-            pygame.mixer.music.stop()
-            pygame.mixer.music.unload()
-        except:
-            pass
-        
-        with self.speaking_lock:
-            self.is_speaking = False
-        
-        for worker in self.audio_workers:
-            if hasattr(worker, 'resume_listening'):
-                try: 
-                    worker.resume_listening()
-                except: 
-                    pass
-
-    def _get_unique_filename(self, ext: str = ".wav"):
-        self.counter += 1
-        return os.path.join(tempfile.gettempdir(), f"xtts_{self.counter}_{int(time.time() * 1000)}{ext}")
-
-    def _generate_speech(self, text: str, filename: str):
-        """Generate speech using Coqui XTTS v2"""
-        try:
-            if self.tts is None:
-                print("[TTS] ❌ Model not initialized")
-                return False
-            
-            print(f"[TTS] 🔧 Generating with {self.voice_name} ({self.language})...")
-            start = time.time()
-            
-            # XTTS v2 Generation
-            self.tts.tts_to_file(
-                text=text,
-                file_path=filename,
-                speaker=self.voice_name,
-                language=self.language,
-                split_sentences=True
-            )
-            
-            gen_time = time.time() - start
-            print(f"[TTS] ✅ Generated in {gen_time:.2f}s")
-            return True
-                
-        except Exception as e:
-            print(f"[TTS] ❌ Error: {e}")
-            import traceback
-            traceback.print_exc()
-            return False
-
-    def _play_audio(self, filename: str):
-        try:
-            if not os.path.exists(filename):
-                return False
-            
-            print(f"[TTS] ▶️ Playing...")
-            pygame.mixer.music.load(filename)
-            pygame.mixer.music.play()
-            
-            while pygame.mixer.music.get_busy():
-                pygame.time.Clock().tick(20)
-            
-            pygame.mixer.music.unload()
-            print(f"[TTS] ✅ Done")
-            return True
-            
-        except Exception as e:
-            print(f"[TTS] ❌ Play error: {e}")
-            return False
-
-    def speak(self, text: str):
-        if not text or not text.strip():
-            return
-
-        print(f"\n[TTS] 🔊 Speaking ({self.language}): '{text[:80]}...'")
-
-        # Pause workers (listening)
-        for worker in self.audio_workers:
-            if hasattr(worker, 'pause_listening'):
-                try: 
-                    worker.pause_listening()
-                except: 
-                    pass
-
-        with self.speaking_lock:
-            self.is_speaking = True
-
-        temp_file = self._get_unique_filename(".wav")
-
-        try:
-            if self._generate_speech(text, temp_file):
-                self._play_audio(temp_file)
-                try:
-                    if os.path.exists(temp_file):
-                        os.remove(temp_file)
-                except: 
-                    pass
-                
-        except Exception as e:
-            print(f"[TTS] ❌ Error: {e}")
-        finally:
-            with self.speaking_lock:
-                self.is_speaking = False
-
-            time.sleep(0.2)
-            
-            # Resume workers
-            for worker in self.audio_workers:
-                if hasattr(worker, 'resume_listening'):
-                    try: 
-                        worker.resume_listening()
-                    except: 
-                        pass
-
-    def speak_async(self, text: str):
-        threading.Thread(target=self.speak, args=(text,), daemon=True).start()
-
-    def get_is_speaking(self) -> bool:
-        with self.speaking_lock:
-            return self.is_speaking

mrrrme/avatar/avatar_controller.py

@@ -1,127 +0,0 @@
-"""Avatar Controller - Integrates avatar with MrrrMe pipeline"""
-import threading
-import time
-import requests
-
-
-class AvatarController:
-    """Sends speech to avatar backend instead of playing locally"""
-    
-    def __init__(self, server_url: str = "http://localhost:8765"):
-        self.server_url = server_url
-        self.is_speaking = False
-        self.speaking_lock = threading.Lock()
-        self.audio_workers = []
-        
-        print(f"[AvatarController] Initializing...")
-        print(f"[AvatarController] Backend: {server_url}")
-        
-        # Test connection
-        try:
-            response = requests.get(f"{server_url}/", timeout=2)
-            data = response.json()
-            print(f"[AvatarController] ✅ Backend connected")
-            print(f"[AvatarController] Available voices: {data.get('voices_available', [])}")
-        except:
-            print(f"[AvatarController] ⚠️ Backend not responding!")
-    
-    def register_audio_worker(self, worker):
-        self.audio_workers.append(worker)
-        print(f"[AvatarController] Registered worker: {worker.__class__.__name__}")
-    
-    def apply_emotion_voice(self, emotion: str, intensity: float):
-        pass
-    
-    def speak(self, text: str, voice: str = "female", language: str = "en"):
-        """Send text to avatar backend with voice and language preferences"""
-        if not text or not text.strip():
-            return
-        
-        t_start = time.time()
-        print(f"\n{'='*50}")
-        print(f"[AvatarController] Starting TTS")
-        print(f"[AvatarController] Text: '{text[:60]}...'")
-        print(f"[AvatarController] Voice: {voice}, Language: {language}")
-        
-        # Pause workers
-        paused_count = 0
-        for worker in self.audio_workers:
-            if hasattr(worker, 'pause_listening'):
-                try:
-                    worker.pause_listening()
-                    paused_count += 1
-                except Exception as e:
-                    print(f"[AvatarController] ⚠️ Failed to pause: {e}")
-        
-        print(f"[AvatarController] Paused {paused_count} workers")
-        time.sleep(0.1)
-        
-        with self.speaking_lock:
-            self.is_speaking = True
-        
-        try:
-            print(f"[AvatarController] Sending to backend...")
-            
-            response = requests.post(
-                f"{self.server_url}/speak",
-                data={
-                    "text": text,
-                    "voice": voice,
-                    "language": language
-                },
-                timeout=45
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                duration = data.get('duration', len(text) * 0.05)
-                
-                print(f"[AvatarController] ✅ TTS generated")
-                print(f"[AvatarController] Duration: {duration:.1f}s")
-                
-                # Wait for playback
-                time.sleep(duration + 1.0)
-                
-                print(f"[AvatarController] ✅ Playback complete")
-            else:
-                print(f"[AvatarController] ❌ Backend error: {response.status_code}")
-                print(f"[AvatarController] Response: {response.text}")
-                time.sleep(2)
-        
-        except requests.exceptions.ConnectionError:
-            print(f"[AvatarController] ❌ Cannot connect to {self.server_url}")
-            time.sleep(2)
-        except Exception as e:
-            print(f"[AvatarController] ❌ Error: {e}")
-            time.sleep(2)
-        
-        finally:
-            with self.speaking_lock:
-                self.is_speaking = False
-            
-            time.sleep(0.5)
-            
-            # Resume workers
-            resumed_count = 0
-            for worker in self.audio_workers:
-                if hasattr(worker, 'resume_listening'):
-                    try:
-                        worker.resume_listening()
-                        resumed_count += 1
-                    except: pass
-            
-            t_end = time.time()
-            print(f"[AvatarController] Resumed {resumed_count} workers")
-            print(f"[AvatarController] Total time: {t_end-t_start:.2f}s")
-            print(f"{'='*50}\n")
-    
-    def speak_async(self, text: str, voice: str = "female", language: str = "en"):
-        """Speak asynchronously with voice and language"""
-        threading.Thread(target=self.speak, args=(text, voice, language), daemon=True).start()
-    
-    def get_is_speaking(self) -> bool:
-        with self.speaking_lock:
-            return self.is_speaking
-    
-    def stop(self):
-        pass

mrrrme/backend_server_old.py

@@ -1,1123 +0,0 @@
-"""MrrrMe Backend WebSocket Server - ENHANCED LOGGING VERSION"""
-import os
-import sys
-
-# ===== SET CACHE DIRECTORIES FIRST =====
-os.environ['HF_HOME'] = '/tmp/huggingface'
-os.environ['TRANSFORMERS_CACHE'] = '/tmp/transformers'
-os.environ['HF_HUB_CACHE'] = '/tmp/huggingface/hub'
-os.environ['TORCH_HOME'] = '/tmp/torch'
-os.makedirs('/tmp/huggingface', exist_ok=True)
-os.makedirs('/tmp/transformers', exist_ok=True)
-os.makedirs('/tmp/huggingface/hub', exist_ok=True)
-os.makedirs('/tmp/torch', exist_ok=True)
-
-# ===== GPU FIX: Patch TensorBoard =====
-class DummySummaryWriter:
-    def __init__(self, *args, **kwargs): pass
-    def __getattr__(self, name): return lambda *args, **kwargs: None
-
-try:
-    import tensorboardX
-    tensorboardX.SummaryWriter = DummySummaryWriter
-except: pass
-
-# ===== GPU FIX: Patch Logging to redirect /work paths =====
-import logging
-_original_FileHandler = logging.FileHandler
-
-class RedirectingFileHandler(_original_FileHandler):
-    def __init__(self, filename, mode='a', encoding=None, delay=False, errors=None):
-        if isinstance(filename, str) and filename.startswith('/work'):
-            filename = '/tmp/openface_log.txt'
-        os.makedirs(os.path.dirname(filename) if os.path.dirname(filename) else '/tmp', exist_ok=True)
-        super().__init__(filename, mode, encoding, delay, errors)
-
-logging.FileHandler = RedirectingFileHandler
-
-# Now import everything else
-import asyncio
-import json
-import base64
-import numpy as np
-import cv2
-import io
-import torch
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel
-import requests
-from PIL import Image
-from typing import Optional
-import sqlite3
-import secrets
-import hashlib
-from datetime import datetime
-
-# Check GPU
-if not torch.cuda.is_available():
-    print("[Backend] ⚠️ No GPU detected - using CPU mode")
-else:
-    print(f"[Backend] ✅ GPU available: {torch.cuda.get_device_name(0)}")
-
-app = FastAPI()
-
-# CORS for browser access
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global model variables (will be loaded after startup)
-face_processor = None
-text_analyzer = None
-whisper_worker = None
-voice_worker = None
-llm_generator = None
-fusion_engine = None
-models_ready = False
-
-# Avatar backend URL - environment aware
-def get_avatar_api_url():
-    """Get correct avatar API URL based on environment"""
-    # For Hugging Face Spaces, use same host
-    if os.path.exists('/.dockerenv') or os.environ.get('SPACE_ID'):
-        # Running in Docker/HF Spaces - use internal networking
-        return "http://127.0.0.1:8765"
-    else:
-        # Local development
-        return "http://localhost:8765"
-
-AVATAR_API = get_avatar_api_url()
-print(f"[Backend] 🎭 Avatar API URL: {AVATAR_API}")
-
-# ===== AUTHENTICATION & DATABASE =====
-# Use /data for Hugging Face Spaces (persistent) or /tmp for local dev
-if os.path.exists('/data'):
-    DB_PATH = "/data/mrrrme_users.db"
-    print("[Backend] 📁 Using persistent storage: /data/mrrrme_users.db")
-else:
-    DB_PATH = "/tmp/mrrrme_users.db"
-    print("[Backend] ⚠️ Using ephemeral storage: /tmp/mrrrme_users.db (will reset on rebuild!)")
-    print("[Backend] ⚠️ To persist data, enable persistent storage in HF Spaces settings")
-
-class SignupRequest(BaseModel):
-    username: str
-    password: str
-
-class LoginRequest(BaseModel):
-    username: str
-    password: str
-
-def init_db():
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS users (
-            user_id TEXT PRIMARY KEY,
-            username TEXT UNIQUE NOT NULL,
-            password_hash TEXT NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    """)
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS sessions (
-            session_id TEXT PRIMARY KEY,
-            user_id TEXT NOT NULL,
-            token TEXT UNIQUE NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            is_active BOOLEAN DEFAULT 1
-        )
-    """)
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS messages (
-            message_id INTEGER PRIMARY KEY AUTOINCREMENT,
-            session_id TEXT NOT NULL,
-            role TEXT NOT NULL,
-            content TEXT NOT NULL,
-            emotion TEXT,
-            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    """)
-    
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS user_summaries (
-            user_id TEXT PRIMARY KEY,
-            summary_text TEXT NOT NULL,
-            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-        )
-    """)
-    
-    conn.commit()
-    conn.close()
-
-init_db()
-
-def hash_password(pw: str) -> str:
-    return hashlib.sha256(pw.encode()).hexdigest()
-
-@app.post("/api/signup")
-async def signup(req: SignupRequest):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    try:
-        user_id = secrets.token_urlsafe(16)
-        cursor.execute(
-            "INSERT INTO users (user_id, username, password_hash) VALUES (?, ?, ?)",
-            (user_id, req.username, hash_password(req.password))
-        )
-        conn.commit()
-        conn.close()
-        return {"success": True, "message": "Account created!"}
-    except sqlite3.IntegrityError:
-        conn.close()
-        raise HTTPException(status_code=400, detail="Username already exists")
-
-@app.post("/api/login")
-async def login(req: LoginRequest):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute(
-        "SELECT user_id, username FROM users WHERE username = ? AND password_hash = ?",
-        (req.username, hash_password(req.password))
-    )
-    
-    result = cursor.fetchone()
-    
-    if not result:
-        conn.close()
-        raise HTTPException(status_code=401, detail="Invalid credentials")
-    
-    user_id, username = result
-    
-    session_id = secrets.token_urlsafe(16)
-    token = secrets.token_urlsafe(32)
-    
-    cursor.execute(
-        "INSERT INTO sessions (session_id, user_id, token) VALUES (?, ?, ?)",
-        (session_id, user_id, token)
-    )
-    
-    cursor.execute(
-        "SELECT summary_text FROM user_summaries WHERE user_id = ?",
-        (user_id,)
-    )
-    summary_row = cursor.fetchone()
-    summary = summary_row[0] if summary_row else None
-    
-    conn.commit()
-    conn.close()
-    
-    return {
-        "success": True,
-        "token": token,
-        "username": username,
-        "user_id": user_id,
-        "summary": summary
-    }
-
-class LogoutRequest(BaseModel):
-    token: str
-
-@app.post("/api/logout")
-async def logout(req: LogoutRequest):
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    # Get session info before closing
-    cursor.execute(
-        "SELECT session_id, user_id FROM sessions WHERE token = ? AND is_active = 1",
-        (req.token,)
-    )
-    result = cursor.fetchone()
-    
-    if result:
-        session_id, user_id = result
-        
-        # Mark session as inactive
-        cursor.execute(
-            "UPDATE sessions SET is_active = 0 WHERE token = ?",
-            (req.token,)
-        )
-        conn.commit()
-        conn.close()
-        
-        # Generate summary on explicit logout
-        print(f"[Logout] 📝 Generating summary for user {user_id}...")
-        summary = await generate_session_summary(session_id, user_id)
-        if summary:
-            print(f"[Logout] ✅ Summary generated")
-        
-        return {"success": True, "message": "Logged out successfully"}
-    else:
-        conn.close()
-        return {"success": True, "message": "Session already closed"}
-
-async def generate_session_summary(session_id: str, user_id: str):
-    """Generate AI summary of conversation for THIS specific user"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    # Verify session belongs to user
-    cursor.execute(
-        "SELECT user_id FROM sessions WHERE session_id = ?",
-        (session_id,)
-    )
-    session_owner = cursor.fetchone()
-    
-    if not session_owner or session_owner[0] != user_id:
-        print(f"[Summary] ❌ Security error: session {session_id} doesn't belong to user {user_id}")
-        conn.close()
-        return None
-    
-    # Get messages from this session
-    cursor.execute(
-        "SELECT role, content, emotion FROM messages WHERE session_id = ? ORDER BY timestamp ASC",
-        (session_id,)
-    )
-    
-    messages = cursor.fetchall()
-    
-    # Get username for better logging
-    cursor.execute("SELECT username FROM users WHERE user_id = ?", (user_id,))
-    username_row = cursor.fetchone()
-    username = username_row[0] if username_row else user_id
-    
-    conn.close()
-    
-    if len(messages) < 3:
-        print(f"[Summary] ⏭️ Skipped for {username} (only {len(messages)} messages)")
-        return None
-    
-    conversation = ""
-    for role, content, emotion in messages:
-        speaker = "User" if role == "user" else "AI"
-        emo_tag = f" [{emotion}]" if emotion else ""
-        conversation += f"{speaker}{emo_tag}: {content}\n"
-    
-    try:
-        from groq import Groq
-        groq_client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-        
-        prompt = f"""Analyze this conversation and create a 2-3 sentence summary about THIS SPECIFIC USER.
-
-DO NOT include information about other users or other conversations.
-ONLY summarize what THIS user said and their patterns.
-
-Conversation ({len(messages)} messages):
-{conversation}
-
-Create a concise summary including: topics this user discussed, their emotional patterns, personal details THEY mentioned, and their preferences."""
-        
-        response = groq_client.chat.completions.create(
-            model="llama-3.1-8b-instant",
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=150,
-            temperature=0.7
-        )
-        
-        summary = response.choices[0].message.content.strip()
-        
-        # Save summary FOR THIS USER ONLY
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        
-        cursor.execute(
-            "INSERT OR REPLACE INTO user_summaries (user_id, summary_text, updated_at) VALUES (?, ?, ?)",
-            (user_id, summary, datetime.now())
-        )
-        
-        conn.commit()
-        conn.close()
-        
-        print(f"[Summary] ✅ Generated for {username} (user_id: {user_id})")
-        print(f"[Summary] 📝 Content: {summary}")
-        return summary
-        
-    except Exception as e:
-        print(f"[Summary] ❌ Error for {username}: {e}")
-        import traceback
-        traceback.print_exc()
-        return None
-
-@app.on_event("startup")
-async def startup_event():
-    """Start loading models in background after server is ready"""
-    print("[Backend] 🚀 Starting up...")
-    
-    # Check if avatar service is running
-    try:
-        response = requests.get(f"{AVATAR_API}/", timeout=2)
-        if response.status_code == 200:
-            print(f"[Backend] ✅ Avatar TTS service available at {AVATAR_API}")
-        else:
-            print(f"[Backend] ⚠️ Avatar TTS service responded with {response.status_code}")
-    except requests.exceptions.ConnectionError:
-        print(f"[Backend] ⚠️ Avatar TTS service NOT available at {AVATAR_API}")
-        print(f"[Backend] 💡 Text-only mode will be used (no avatar speech)")
-        print(f"[Backend] 📝 To enable avatar:")
-        print(f"[Backend]    cd avatar && python speak_server.py")
-    except Exception as e:
-        print(f"[Backend] ⚠️ Error checking avatar service: {e}")
-    
-    asyncio.create_task(load_models())
-
-async def load_models():
-    """Load all AI models asynchronously"""
-    global face_processor, text_analyzer, whisper_worker, voice_worker
-    global llm_generator, fusion_engine, models_ready
-    
-    print("[Backend] 🚀 Initializing MrrrMe AI models in background...")
-    
-    try:
-        # Import modules
-        from mrrrme.vision.face_processor import FaceProcessor
-        from mrrrme.audio.voice_emotion import VoiceEmotionWorker
-        from mrrrme.audio.whisper_transcription import WhisperTranscriptionWorker
-        from mrrrme.nlp.text_sentiment import TextSentimentAnalyzer
-        from mrrrme.nlp.llm_generator_groq import LLMResponseGenerator
-        from mrrrme.config import FUSE4
-        
-        # Load models
-        print("[Backend] Loading FaceProcessor...")
-        face_processor = FaceProcessor()
-        
-        print("[Backend] Loading TextSentiment...")
-        text_analyzer = TextSentimentAnalyzer()
-        
-        print("[Backend] Loading Whisper...")
-        whisper_worker = WhisperTranscriptionWorker(text_analyzer)
-        
-        print("[Backend] Loading VoiceEmotion...")
-        voice_worker = VoiceEmotionWorker(whisper_worker=whisper_worker)
-        
-        print("[Backend] Initializing LLM...")
-        groq_api_key = os.getenv("GROQ_API_KEY", "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")
-        llm_generator = LLMResponseGenerator(api_key=groq_api_key)
-        
-        # Initialize fusion engine
-        class FusionEngine:
-            def __init__(self):
-                self.alpha_face = 0.4
-                self.alpha_voice = 0.3
-                self.alpha_text = 0.3
-            
-            def fuse(self, face_probs, voice_probs, text_probs):
-                fused = (
-                    self.alpha_face * face_probs +
-                    self.alpha_voice * voice_probs +
-                    self.alpha_text * text_probs
-                )
-                fused = fused / (np.sum(fused) + 1e-8)
-                fused_idx = int(np.argmax(fused))
-                fused_emotion = FUSE4[fused_idx]
-                intensity = float(np.max(fused))
-                return fused_emotion, intensity
-        
-        fusion_engine = FusionEngine()
-        models_ready = True
-        
-        print("[Backend] ✅ All models loaded!")
-        
-    except Exception as e:
-        print(f"[Backend] ❌ Error loading models: {e}")
-        import traceback
-        traceback.print_exc()
-
-@app.get("/")
-async def root():
-    """Root endpoint"""
-    return {
-        "status": "running",
-        "models_ready": models_ready,
-        "message": "MrrrMe AI Backend"
-    }
-
-@app.get("/health")
-async def health():
-    """Health check - responds immediately"""
-    return {
-        "status": "healthy",
-        "models_ready": models_ready
-    }
-
-@app.get("/api/debug/users")
-async def debug_users():
-    """Debug endpoint - view all users and their summaries"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("""
-        SELECT u.username, u.user_id, s.summary_text, s.updated_at
-        FROM users u
-        LEFT JOIN user_summaries s ON u.user_id = s.user_id
-        ORDER BY u.created_at DESC
-    """)
-    
-    users = []
-    for username, user_id, summary, updated in cursor.fetchall():
-        users.append({
-            "username": username,
-            "user_id": user_id,
-            "summary": summary,
-            "summary_updated": updated
-        })
-    
-    conn.close()
-    
-    return {"users": users, "database": DB_PATH}
-
-@app.get("/api/debug/sessions")
-async def debug_sessions():
-    """Debug endpoint - view all active sessions"""
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    
-    cursor.execute("""
-        SELECT s.session_id, s.token, u.username, s.is_active, s.created_at
-        FROM sessions s
-        JOIN users u ON s.user_id = u.user_id
-        ORDER BY s.created_at DESC
-        LIMIT 20
-    """)
-    
-    sessions = []
-    for session_id, token, username, is_active, created_at in cursor.fetchall():
-        sessions.append({
-            "session_id": session_id,
-            "token_preview": token[:10] + "..." if token else None,
-            "username": username,
-            "is_active": bool(is_active),
-            "created_at": created_at
-        })
-    
-    conn.close()
-    
-    return {"sessions": sessions, "database": DB_PATH}
-
-@app.websocket("/ws")
-async def websocket_endpoint(websocket: WebSocket):
-    await websocket.accept()
-    print("[WebSocket] ✅ Client connected!")
-    
-    # ===== AUTHENTICATION =====
-    session_data = None
-    user_summary = None
-    session_id = None
-    user_id = None
-    username = None
-    
-    try:
-        auth_msg = await websocket.receive_json()
-        print(f"[WebSocket] 📨 Auth message received: {auth_msg.get('type')}")
-        
-        if auth_msg.get("type") != "auth":
-            print(f"[WebSocket] ❌ Wrong message type: {auth_msg.get('type')}")
-            await websocket.send_json({"type": "error", "message": "Authentication required"})
-            return
-        
-        token = auth_msg.get("token")
-        print(f"[WebSocket] 🔑 Validating token: {token[:10] if token else 'None'}...")
-        
-        if not token:
-            print(f"[WebSocket] ❌ No token provided!")
-            await websocket.send_json({"type": "error", "message": "No token provided"})
-            return
-        
-        # Validate token
-        conn = sqlite3.connect(DB_PATH)
-        cursor = conn.cursor()
-        
-        cursor.execute(
-            "SELECT s.session_id, s.user_id, u.username FROM sessions s JOIN users u ON s.user_id = u.user_id WHERE s.token = ? AND s.is_active = 1",
-            (token,)
-        )
-        
-        result = cursor.fetchone()
-        
-        if not result:
-            # Debug: Check if token exists at all
-            cursor.execute("SELECT session_id, user_id, is_active FROM sessions WHERE token = ?", (token,))
-            debug_result = cursor.fetchone()
-            
-            if debug_result:
-                print(f"[WebSocket] ⚠️ Token found but session inactive or invalid: {debug_result}")
-            else:
-                print(f"[WebSocket] ❌ Token not found in database!")
-            
-            await websocket.send_json({"type": "error", "message": "Invalid session - please login again"})
-            conn.close()
-            return
-        
-        session_id, user_id, username = result
-        print(f"[WebSocket] ✅ Token validated for user: {username} (session: {session_id})")
-        
-        # Get user-specific summary
-        cursor.execute(
-            "SELECT summary_text FROM user_summaries WHERE user_id = ?",
-            (user_id,)
-        )
-        summary_row = cursor.fetchone()
-        user_summary = summary_row[0] if summary_row else None
-        
-        conn.close()
-        
-        session_data = {
-            'session_id': session_id,
-            'user_id': user_id,
-            'username': username
-        }
-        
-        # Send authenticated confirmation
-        await websocket.send_json({
-            "type": "authenticated",
-            "username": username,
-            "summary": user_summary
-        })
-        
-        print(f"[WebSocket] ✅ Authenticated: {username} (user_id: {user_id})")
-        if user_summary:
-            print(f"[WebSocket] 📖 Loaded summary: {user_summary[:60]}...")
-        
-        # Clear LLM's conversation history
-        if llm_generator:
-            llm_generator.clear_history()
-            print(f"[LLM] 🗑️ Conversation history cleared")
-            
-            # Load user's recent conversation history
-            conn = sqlite3.connect(DB_PATH)
-            cursor = conn.cursor()
-            cursor.execute(
-                """SELECT role, content FROM messages 
-                   WHERE session_id IN (
-                       SELECT session_id FROM sessions WHERE user_id = ?
-                   )
-                   ORDER BY timestamp DESC 
-                   LIMIT 10""",
-                (user_id,)
-            )
-            user_history = cursor.fetchall()
-            conn.close()
-            
-            # Load user-specific history into LLM
-            for role, content in reversed(user_history):
-                llm_generator.conversation_history.append({
-                    "role": role,
-                    "content": content
-                })
-            
-            if user_history:
-                print(f"[WebSocket] 📚 Loaded {len(user_history)} messages from {username}'s history")
-    
-    except Exception as auth_err:
-        print(f"[WebSocket] ❌ Auth error: {auth_err}")
-        return
-    
-    # Wait for models to load if needed
-    if not models_ready:
-        await websocket.send_json({
-            "type": "status",
-            "message": "AI models are loading, please wait..."
-        })
-        
-        # Wait up to 15 minutes for models
-        for _ in range(900):
-            if models_ready:
-                await websocket.send_json({
-                    "type": "status",
-                    "message": "Models loaded! Ready to chat."
-                })
-                break
-            await asyncio.sleep(1)
-        
-        if not models_ready:
-            await websocket.send_json({
-                "type": "error",
-                "message": "Models failed to load. Please refresh."
-            })
-            return
-    
-    # Session state
-    audio_buffer = []
-    user_preferences = {"voice": "female", "language": "en"}
-    
-    try:
-        while True:
-            data = await websocket.receive_json()
-            msg_type = data.get("type")
-            
-            # ============ PREFERENCES UPDATE ============
-            if msg_type == "preferences":
-                if "voice" in data:
-                    user_preferences["voice"] = data.get("voice", "female")
-                if "language" in data:
-                    user_preferences["language"] = data.get("language", "en")
-                print(f"[Preferences] {username}: voice={user_preferences.get('voice')}, language={user_preferences.get('language')}")
-                continue
-            
-            # ============ AUTO-GREETING REQUEST ============
-            elif msg_type == "request_greeting":
-                try:
-                    print(f"[WebSocket] 🤖 Generating initial greeting for {username}...")
-                    
-                    # Determine greeting based on user context
-                    greeting_prompts = {
-                        "new": f"Hey {username}! I'm MrrrMe, your emotion AI companion. How are you feeling today?",
-                        "returning": f"Welcome back, {username}! It's great to see you again. How have you been?"
-                    }
-                    
-                    # Check if user has summary (returning user)
-                    greeting_text = greeting_prompts["returning"] if user_summary else greeting_prompts["new"]
-                    
-                    # Add language context
-                    if user_preferences.get("language") == "nl":
-                        if user_summary:
-                            greeting_text = f"Welkom terug, {username}! Fijn je weer te zien. Hoe gaat het met je?"
-                        else:
-                            greeting_text = f"Hoi {username}! Ik ben MrrrMe, jouw emotie AI-metgezel. Hoe voel je je vandaag?"
-                    
-                    print(f"[Greeting] 👋 Sending: '{greeting_text}'")
-                    
-                    # Try to send to avatar for TTS
-                    audio_url = None
-                    visemes = None
-                    
-                    try:
-                        voice_preference = user_preferences.get("voice", "female")
-                        language_preference = user_preferences.get("language", "en")
-                        
-                        print(f"[Greeting] 🔊 Requesting TTS from avatar service...")
-                        avatar_response = requests.post(
-                            f"{AVATAR_API}/speak",
-                            data={
-                                "text": greeting_text,
-                                "voice": voice_preference,
-                                "language": language_preference
-                            },
-                            timeout=10
-                        )
-                        
-                        if avatar_response.status_code == 200:
-                            avatar_data = avatar_response.json()
-                            audio_url = avatar_data.get("audio_url")
-                            visemes = avatar_data.get("visemes")
-                            print(f"[Greeting] ✅ TTS generated successfully")
-                        else:
-                            print(f"[Greeting] ⚠️ TTS failed: {avatar_response.status_code}")
-                    
-                    except requests.exceptions.ConnectionError as conn_err:
-                        print(f"[Greeting] ⚠️ Avatar service not available (port 8765 not responding)")
-                        print(f"[Greeting] 📝 Sending text-only greeting (TTS will be skipped)")
-                    
-                    except Exception as tts_err:
-                        print(f"[Greeting] ⚠️ TTS error: {tts_err}")
-                        print(f"[Greeting] 📝 Sending text-only greeting")
-                    
-                    # Send greeting to client
-                    response_data = {
-                        "type": "llm_response",
-                        "text": greeting_text,
-                        "emotion": "Neutral",
-                        "intensity": 0.5,
-                        "is_greeting": True
-                    }
-                    
-                    # Add audio/visemes only if TTS succeeded
-                    if audio_url and visemes:
-                        response_data["audio_url"] = audio_url
-                        response_data["visemes"] = visemes
-                    else:
-                        response_data["text_only"] = True
-                        print(f"[Greeting] 📝 Sending text-only (no TTS)")
-                    
-                    await websocket.send_json(response_data)
-                    
-                    # Save greeting to history
-                    conn = sqlite3.connect(DB_PATH)
-                    cursor = conn.cursor()
-                    cursor.execute(
-                        "INSERT INTO messages (session_id, role, content, emotion) VALUES (?, ?, ?, ?)",
-                        (session_id, "assistant", greeting_text, "Neutral")
-                    )
-                    conn.commit()
-                    conn.close()
-                    
-                    print(f"[Greeting] ✅ Sent to {username}")
-                    
-                except Exception as greeting_err:
-                    print(f"[Greeting] ❌ Error: {greeting_err}")
-                    import traceback
-                    traceback.print_exc()
-                    
-                    try:
-                        await websocket.send_json({
-                            "type": "error",
-                            "message": "Greeting failed - avatar service unavailable"
-                        })
-                    except:
-                        pass
-            
-            # ============ VIDEO FRAME - UPDATED WITH PROBABILITIES ============
-            elif msg_type == "video_frame":
-                try:
-                    # Decode base64 image
-                    img_data = base64.b64decode(data["frame"].split(",")[1])
-                    img = Image.open(io.BytesIO(img_data))
-                    frame = cv2.cvtColor(np.array(img), cv2.COLOR_RGB2BGR)
-                    
-                    # Process face emotion
-                    try:
-                        processed_frame, result = face_processor.process_frame(frame)
-                        face_emotion = face_processor.get_last_emotion() or "Neutral"
-                        face_confidence = face_processor.get_last_confidence() or 0.0
-                        face_probs = face_processor.get_last_probs()
-                        face_quality = face_processor.get_last_quality() if hasattr(face_processor, 'get_last_quality') else 0.5
-                    except Exception as proc_err:
-                        print(f"[FaceProcessor] Error: {proc_err}")
-                        face_emotion = "Neutral"
-                        face_confidence = 0.0
-                        face_probs = np.array([0.25, 0.25, 0.25, 0.25])
-                        face_quality = 0.0
-                    
-                    # Send face emotion to frontend with probabilities
-                    await websocket.send_json({
-                        "type": "face_emotion",
-                        "emotion": face_emotion,
-                        "confidence": face_confidence,
-                        "probabilities": face_probs.tolist(),
-                        "quality": face_quality
-                    })
-                    
-                except Exception as e:
-                    print(f"[Video] Error: {e}")
-            
-            # ============ AUDIO CHUNK ============
-            elif msg_type == "audio_chunk":
-                try:
-                    audio_data = base64.b64decode(data["audio"])
-                    audio_buffer.append(audio_data)
-                    
-                    if len(audio_buffer) >= 5:
-                        voice_probs, voice_emotion = voice_worker.get_probs()
-                        await websocket.send_json({
-                            "type": "voice_emotion",
-                            "emotion": voice_emotion
-                        })
-                        audio_buffer = audio_buffer[-3:]
-                    
-                except Exception as e:
-                    print(f"[Audio] Error: {e}")
-            
-            # ============ USER FINISHED SPEAKING (ENHANCED LOGGING) ============
-            elif msg_type == "speech_end":
-                transcription = data.get("text", "").strip()
-                
-                print(f"\n{'='*80}")
-                print(f"[Speech End] 🎤 USER FINISHED SPEAKING: {username}")
-                print(f"{'='*80}")
-                print(f"[Transcription] '{transcription}'")
-                
-                # Filter short/meaningless
-                if len(transcription) < 2:
-                    print(f"[Filter] ⏭️ Skipped: Too short ({len(transcription)} chars)")
-                    continue
-                
-                hallucinations = {"thank you", "thanks", "okay", "ok", "you", "yeah", "yep"}
-                if transcription.lower().strip('.,!?') in hallucinations:
-                    print(f"[Filter] ⏭️ Skipped: Hallucination detected ('{transcription}')")
-                    continue
-                
-                # Save user message
-                conn = sqlite3.connect(DB_PATH)
-                cursor = conn.cursor()
-                cursor.execute(
-                    "INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)",
-                    (session_id, "user", transcription)
-                )
-                conn.commit()
-                conn.close()
-                
-                try:
-                    # ========== EMOTION DETECTION PIPELINE (ENHANCED LOGGING) ==========
-                    print(f"\n[Pipeline] 🔍 Starting emotion analysis pipeline...")
-                    print(f"{'─'*80}")
-                    
-                    # Step 1: Get face emotion
-                    print(f"[Step 1/4] 📸 FACIAL EXPRESSION ANALYSIS")
-                    face_emotion = face_processor.get_last_emotion()
-                    face_confidence = face_processor.get_last_confidence()
-                    face_quality = face_processor.get_last_quality() if hasattr(face_processor, 'get_last_quality') else 0.5
-                    
-                    # Create emotion probabilities
-                    emotion_map = {'Neutral': 0, 'Happy': 1, 'Sad': 2, 'Angry': 3}
-                    face_probs = np.array([0.25, 0.25, 0.25, 0.25], dtype=np.float32)
-                    if face_emotion in emotion_map:
-                        face_idx = emotion_map[face_emotion]
-                        face_probs[face_idx] = face_confidence
-                        face_probs = face_probs / face_probs.sum()
-                    
-                    print(f"   Result: {face_emotion}")
-                    print(f"   Confidence: {face_confidence:.3f}")
-                    print(f"   Quality Score: {face_quality:.3f}")
-                    print(f"   Distribution: Neutral={face_probs[0]:.3f} | Happy={face_probs[1]:.3f} | Sad={face_probs[2]:.3f} | Angry={face_probs[3]:.3f}")
-                    
-                    # Step 2: Get voice emotion
-                    print(f"\n[Step 2/4] 🎤 VOICE TONE ANALYSIS")
-                    voice_probs, voice_emotion = voice_worker.get_probs()
-                    voice_state = voice_worker.get_state()
-                    voice_active = voice_state.get('speech_active', False)
-                    voice_inferences = voice_state.get('inference_count', 0)
-                    voice_skipped = voice_state.get('skipped_inferences', 0)
-                    
-                    print(f"   {'✅ ACTIVELY PROCESSING' if voice_active else '⚠️ IDLE (no recent speech)'}")
-                    print(f"   Result: {voice_emotion}")
-                    print(f"   Distribution: Neutral={voice_probs[0]:.3f} | Happy={voice_probs[1]:.3f} | Sad={voice_probs[2]:.3f} | Angry={voice_probs[3]:.3f}")
-                    print(f"   Inferences completed: {voice_inferences}")
-                    print(f"   Skipped (silence optimization): {voice_skipped}")
-                    efficiency = (voice_inferences / (voice_inferences + voice_skipped) * 100) if (voice_inferences + voice_skipped) > 0 else 0
-                    print(f"   Processing efficiency: {efficiency:.1f}%")
-                    
-                    # Step 3: Analyze text sentiment
-                    print(f"\n[Step 3/4] 💬 TEXT SENTIMENT ANALYSIS")
-                    print(f"   ✅ Using Whisper transcription")
-                    text_analyzer.analyze(transcription)
-                    text_probs, _ = text_analyzer.get_probs()
-                    text_emotion = ['Neutral', 'Happy', 'Sad', 'Angry'][int(np.argmax(text_probs))]
-                    
-                    print(f"   Result: {text_emotion}")
-                    print(f"   Distribution: Neutral={text_probs[0]:.3f} | Happy={text_probs[1]:.3f} | Sad={text_probs[2]:.3f} | Angry={text_probs[3]:.3f}")
-                    print(f"   Text length: {len(transcription)} characters")
-                    
-                    # Step 4: Calculate fusion weights
-                    print(f"\n[Step 4/4] ⚖️  MULTI-MODAL FUSION")
-                    base_weights = {
-                        'face': fusion_engine.alpha_face,
-                        'voice': fusion_engine.alpha_voice,
-                        'text': fusion_engine.alpha_text
-                    }
-                    
-                    # Adjust weights based on quality/confidence
-                    adjusted_weights = base_weights.copy()
-                    adjustments_made = []
-                    
-                    # Reduce face weight if quality is poor
-                    if face_quality < 0.5:
-                        adjusted_weights['face'] *= 0.7
-                        adjustments_made.append(f"Face weight reduced (low quality: {face_quality:.3f})")
-                    
-                    # Reduce voice weight if not active
-                    if not voice_active:
-                        adjusted_weights['voice'] *= 0.5
-                        adjustments_made.append(f"Voice weight reduced (no recent speech)")
-                    
-                    # Reduce text weight if very short
-                    if len(transcription) < 10:
-                        adjusted_weights['text'] *= 0.7
-                        adjustments_made.append(f"Text weight reduced (short input: {len(transcription)} chars)")
-                    
-                    # Normalize weights to sum to 1.0
-                    total_weight = sum(adjusted_weights.values())
-                    final_weights = {k: v/total_weight for k, v in adjusted_weights.items()}
-                    
-                    print(f"   Base weights:     Face={base_weights['face']:.3f} | Voice={base_weights['voice']:.3f} | Text={base_weights['text']:.3f}")
-                    if adjustments_made:
-                        print(f"   Adjustments:")
-                        for adj in adjustments_made:
-                            print(f"      - {adj}")
-                    print(f"   Final weights:    Face={final_weights['face']:.3f} | Voice={final_weights['voice']:.3f} | Text={final_weights['text']:.3f}")
-                    
-                    # Calculate weighted fusion
-                    fused_probs = (
-                        final_weights['face'] * face_probs +
-                        final_weights['voice'] * voice_probs +
-                        final_weights['text'] * text_probs
-                    )
-                    fused_probs = fused_probs / (np.sum(fused_probs) + 1e-8)
-                    
-                    fused_emotion, intensity = fusion_engine.fuse(face_probs, voice_probs, text_probs)
-                    
-                    # Calculate fusion accuracy metrics
-                    agreement_count = sum([
-                        face_emotion == fused_emotion,
-                        voice_emotion == fused_emotion,
-                        text_emotion == fused_emotion
-                    ])
-                    agreement_score = agreement_count / 3.0
-                    
-                    # Check for conflicts
-                    all_same = (face_emotion == voice_emotion == text_emotion)
-                    has_conflict = len({face_emotion, voice_emotion, text_emotion}) == 3
-                    
-                    print(f"\n   {'─'*76}")
-                    print(f"   FUSION RESULTS:")
-                    print(f"   {'─'*76}")
-                    print(f"   Input emotions:")
-                    print(f"      Face:  {face_emotion:7s} (confidence={face_probs[emotion_map.get(face_emotion, 0)]:.3f}, weight={final_weights['face']:.3f})")
-                    print(f"      Voice: {voice_emotion:7s} (confidence={voice_probs[emotion_map.get(voice_emotion, 0)]:.3f}, weight={final_weights['voice']:.3f})")
-                    print(f"      Text:  {text_emotion:7s} (confidence={text_probs[emotion_map.get(text_emotion, 0)]:.3f}, weight={final_weights['text']:.3f})")
-                    print(f"   {'─'*76}")
-                    print(f"   FUSED EMOTION: {fused_emotion}")
-                    print(f"   Intensity: {intensity:.3f}")
-                    print(f"   Fused distribution: Neutral={fused_probs[0]:.3f} | Happy={fused_probs[1]:.3f} | Sad={fused_probs[2]:.3f} | Angry={fused_probs[3]:.3f}")
-                    print(f"   {'─'*76}")
-                    print(f"   Agreement: {agreement_count}/3 modalities ({agreement_score*100:.1f}%)")
-                    
-                    if all_same:
-                        print(f"   Status: ✅ Perfect agreement - all modalities aligned")
-                    elif has_conflict:
-                        print(f"   Status: ⚠️ Full conflict - weighted fusion resolved disagreement")
-                    else:
-                        print(f"   Status: 📊 Partial agreement - majority vote with confidence weighting")
-                    
-                    print(f"   {'─'*76}")
-                    
-                    # ========== LLM INPUT PREPARATION ==========
-                    print(f"\n[LLM Input] 🧠 Preparing context for language model...")
-                    
-                    # Language instruction
-                    user_language = user_preferences.get("language", "en")
-                    
-                    context_prefix = ""
-                    if user_summary:
-                        context_prefix = f"[User context for {username}: {user_summary}]\n\n"
-                        print(f"[LLM Input]    - User context: YES ({len(user_summary)} chars)")
-                    else:
-                        print(f"[LLM Input]    - User context: NO (new user)")
-                    
-                    # Add language instruction
-                    if user_language == "nl":
-                        context_prefix += "[BELANGRIJK: Antwoord ALTIJD in het Nederlands!]\n\n"
-                        print(f"[LLM Input]    - Language: Dutch (Nederlands)")
-                    else:
-                        context_prefix += "[IMPORTANT: ALWAYS respond in English!]\n\n"
-                        print(f"[LLM Input]    - Language: English")
-                    
-                    full_llm_input = context_prefix + transcription
-                    
-                    print(f"[LLM Input]    - Fused emotion: {fused_emotion}")
-                    print(f"[LLM Input]    - Face emotion: {face_emotion}")
-                    print(f"[LLM Input]    - Voice emotion: {voice_emotion}")
-                    print(f"[LLM Input]    - Intensity: {intensity:.3f}")
-                    print(f"[LLM Input]    - User text: '{transcription}'")
-                    print(f"[LLM Input]    - Full prompt length: {len(full_llm_input)} chars")
-                    
-                    if len(context_prefix) > 50:
-                        print(f"[LLM Input]    - Context preview: '{context_prefix[:100]}...'")
-                    
-                    # Generate LLM response
-                    print(f"\n[LLM] 🤖 Generating response...")
-                    response_text = llm_generator.generate_response(
-                        fused_emotion, face_emotion, voice_emotion,
-                        full_llm_input, force=True, intensity=intensity
-                    )
-                    
-                    print(f"[LLM] ✅ Response generated: '{response_text}'")
-                    
-                    # Save assistant message
-                    conn = sqlite3.connect(DB_PATH)
-                    cursor = conn.cursor()
-                    cursor.execute(
-                        "INSERT INTO messages (session_id, role, content, emotion) VALUES (?, ?, ?, ?)",
-                        (session_id, "assistant", response_text, fused_emotion)
-                    )
-                    conn.commit()
-                    conn.close()
-                    
-                    # ========== SEND TO AVATAR FOR TTS ==========
-                    print(f"\n[TTS] 🎭 Sending to avatar backend...")
-                    
-                    try:
-                        voice_preference = user_preferences.get("voice", "female")
-                        language_preference = user_preferences.get("language", "en")
-                        
-                        print(f"[TTS]    - Voice: {voice_preference}")
-                        print(f"[TTS]    - Language: {language_preference}")
-                        print(f"[TTS]    - Text: '{response_text}'")
-                        
-                        avatar_response = requests.post(
-                            f"{AVATAR_API}/speak",
-                            data={
-                                "text": response_text, 
-                                "voice": voice_preference,
-                                "language": language_preference
-                            },
-                            timeout=45
-                        )
-                        avatar_response.raise_for_status()
-                        avatar_data = avatar_response.json()
-                        
-                        print(f"[TTS] ✅ Avatar TTS generated")
-                        print(f"[TTS]    - Audio URL: {avatar_data.get('audio_url', 'N/A')}")
-                        print(f"[TTS]    - Visemes: {len(avatar_data.get('visemes', []))} keyframes")
-                        
-                        await websocket.send_json({
-                            "type": "llm_response",
-                            "text": response_text,
-                            "emotion": fused_emotion,
-                            "intensity": intensity,
-                            "audio_url": avatar_data.get("audio_url"),
-                            "visemes": avatar_data.get("visemes")
-                        })
-                        
-                        print(f"[Pipeline] ✅ Complete response sent to {username}")
-                        
-                    except requests.exceptions.ConnectionError:
-                        print(f"[TTS] ⚠️ Avatar service not available - sending text-only")
-                        await websocket.send_json({
-                            "type": "llm_response",
-                            "text": response_text,
-                            "emotion": fused_emotion,
-                            "intensity": intensity,
-                            "text_only": True
-                        })
-                        
-                    except Exception as avatar_err:
-                        print(f"[TTS] ❌ Avatar error: {avatar_err}")
-                        await websocket.send_json({
-                            "type": "llm_response",
-                            "text": response_text,
-                            "emotion": fused_emotion,
-                            "intensity": intensity,
-                            "error": "Avatar TTS failed",
-                            "text_only": True
-                        })
-                    
-                    print(f"{'='*80}\n")
-                    
-                except Exception as e:
-                    print(f"[Pipeline] ❌ Error in emotion processing: {e}")
-                    import traceback
-                    traceback.print_exc()
-    
-    except WebSocketDisconnect:
-        print(f"[WebSocket] ❌ {username} disconnected (close/refresh)")
-    
-    except Exception as e:
-        print(f"[WebSocket] ❌ {username} error: {e}")
-        import traceback
-        traceback.print_exc()
-    
-    finally:
-        # Generate summary on disconnect
-        if session_data and session_id and user_id:
-            print(f"[WebSocket] 📝 Generating summary for {username} (session ended)...")
-            try:
-                summary = await generate_session_summary(session_id, user_id)
-                if summary:
-                    print(f"[Summary] ✅ Saved for {username}")
-                else:
-                    print(f"[Summary] ⏭️ Skipped (not enough messages)")
-            except Exception as summary_err:
-                print(f"[Summary] ❌ Error for {username}: {summary_err}")
-
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)

mrrrme/database/db_manager.py

@@ -1,333 +0,0 @@
-"""Database manager for user sessions, chat history, and summaries"""
-import sqlite3
-import json
-import hashlib
-import secrets
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Optional, List, Dict
-
-DB_PATH = Path("/tmp/mrrrme_users.db")
-
-
-class DatabaseManager:
-    """Manages user authentication, chat history, and AI-generated summaries"""
-    
-    def __init__(self, db_path: str = str(DB_PATH)):
-        self.db_path = db_path
-        self._init_database()
-        print(f"[Database] ✅ Initialized at {db_path}")
-    
-    def _init_database(self):
-        """Create tables if they don't exist"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        # Users table
-        cursor.execute("""
-            CREATE TABLE IF NOT EXISTS users (
-                user_id TEXT PRIMARY KEY,
-                username TEXT UNIQUE NOT NULL,
-                password_hash TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_login TIMESTAMP,
-                total_sessions INTEGER DEFAULT 0
-            )
-        """)
-        
-        # Sessions table
-        cursor.execute("""
-            CREATE TABLE IF NOT EXISTS sessions (
-                session_id TEXT PRIMARY KEY,
-                user_id TEXT NOT NULL,
-                token TEXT UNIQUE NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                last_activity TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                is_active BOOLEAN DEFAULT 1,
-                FOREIGN KEY (user_id) REFERENCES users(user_id)
-            )
-        """)
-        
-        # Messages table
-        cursor.execute("""
-            CREATE TABLE IF NOT EXISTS messages (
-                message_id INTEGER PRIMARY KEY AUTOINCREMENT,
-                session_id TEXT NOT NULL,
-                user_id TEXT NOT NULL,
-                role TEXT NOT NULL,
-                content TEXT NOT NULL,
-                emotion TEXT,
-                intensity REAL,
-                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (session_id) REFERENCES sessions(session_id),
-                FOREIGN KEY (user_id) REFERENCES users(user_id)
-            )
-        """)
-        
-        # Summaries table (AI-generated user profiles)
-        cursor.execute("""
-            CREATE TABLE IF NOT EXISTS user_summaries (
-                summary_id INTEGER PRIMARY KEY AUTOINCREMENT,
-                user_id TEXT NOT NULL,
-                session_id TEXT,
-                summary_text TEXT NOT NULL,
-                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                message_count INTEGER,
-                FOREIGN KEY (user_id) REFERENCES users(user_id),
-                FOREIGN KEY (session_id) REFERENCES sessions(session_id)
-            )
-        """)
-        
-        conn.commit()
-        conn.close()
-    
-    def _hash_password(self, password: str) -> str:
-        """Hash password with salt"""
-        return hashlib.sha256(password.encode()).hexdigest()
-    
-    def create_user(self, username: str, password: str) -> Optional[str]:
-        """Create new user, returns user_id"""
-        try:
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            user_id = secrets.token_urlsafe(16)
-            password_hash = self._hash_password(password)
-            
-            cursor.execute(
-                "INSERT INTO users (user_id, username, password_hash) VALUES (?, ?, ?)",
-                (user_id, username, password_hash)
-            )
-            
-            conn.commit()
-            conn.close()
-            
-            print(f"[Database] ✅ Created user: {username}")
-            return user_id
-        except sqlite3.IntegrityError:
-            return None
-        except Exception as e:
-            print(f"[Database] ❌ Error creating user: {e}")
-            return None
-    
-    def authenticate_user(self, username: str, password: str) -> Optional[Dict]:
-        """Authenticate user and return user info"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        password_hash = self._hash_password(password)
-        
-        cursor.execute(
-            "SELECT user_id, username FROM users WHERE username = ? AND password_hash = ?",
-            (username, password_hash)
-        )
-        
-        result = cursor.fetchone()
-        
-        if result:
-            user_id, username = result
-            
-            # Update last login
-            cursor.execute(
-                "UPDATE users SET last_login = ?, total_sessions = total_sessions + 1 WHERE user_id = ?",
-                (datetime.now(), user_id)
-            )
-            conn.commit()
-            
-            conn.close()
-            return {'user_id': user_id, 'username': username}
-        
-        conn.close()
-        return None
-    
-    def create_session(self, user_id: str) -> Optional[Dict]:
-        """Create new session for user"""
-        try:
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            session_id = secrets.token_urlsafe(16)
-            token = secrets.token_urlsafe(32)
-            
-            cursor.execute(
-                "INSERT INTO sessions (session_id, user_id, token) VALUES (?, ?, ?)",
-                (session_id, user_id, token)
-            )
-            
-            conn.commit()
-            conn.close()
-            
-            print(f"[Database] ✅ Created session for user {user_id}")
-            return {
-                'session_id': session_id,
-                'token': token,
-                'user_id': user_id
-            }
-        except Exception as e:
-            print(f"[Database] ❌ Error creating session: {e}")
-            return None
-    
-    def validate_token(self, token: str) -> Optional[Dict]:
-        """Validate session token and return session info"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute(
-            """
-            SELECT s.session_id, s.user_id, u.username 
-            FROM sessions s
-            JOIN users u ON s.user_id = u.user_id
-            WHERE s.token = ? AND s.is_active = 1
-            """,
-            (token,)
-        )
-        
-        result = cursor.fetchone()
-        
-        if result:
-            session_id, user_id, username = result
-            
-            # Update last activity
-            cursor.execute(
-                "UPDATE sessions SET last_activity = ? WHERE session_id = ?",
-                (datetime.now(), session_id)
-            )
-            conn.commit()
-            
-            conn.close()
-            return {
-                'session_id': session_id,
-                'user_id': user_id,
-                'username': username
-            }
-        
-        conn.close()
-        return None
-    
-    def add_message(self, session_id: str, user_id: str, role: str, content: str, 
-                   emotion: Optional[str] = None, intensity: Optional[float] = None):
-        """Add message to chat history"""
-        try:
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            cursor.execute(
-                """
-                INSERT INTO messages (session_id, user_id, role, content, emotion, intensity)
-                VALUES (?, ?, ?, ?, ?, ?)
-                """,
-                (session_id, user_id, role, content, emotion, intensity)
-            )
-            
-            conn.commit()
-            conn.close()
-        except Exception as e:
-            print(f"[Database] ❌ Error adding message: {e}")
-    
-    def get_session_messages(self, session_id: str) -> List[Dict]:
-        """Get all messages for a session"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute(
-            """
-            SELECT role, content, emotion, intensity, timestamp
-            FROM messages
-            WHERE session_id = ?
-            ORDER BY timestamp ASC
-            """,
-            (session_id,)
-        )
-        
-        messages = []
-        for row in cursor.fetchall():
-            messages.append({
-                'role': row[0],
-                'content': row[1],
-                'emotion': row[2],
-                'intensity': row[3],
-                'timestamp': row[4]
-            })
-        
-        conn.close()
-        return messages
-    
-    def get_user_summary(self, user_id: str) -> Optional[str]:
-        """Get most recent summary for user"""
-        conn = sqlite3.connect(self.db_path)
-        cursor = conn.cursor()
-        
-        cursor.execute(
-            """
-            SELECT summary_text
-            FROM user_summaries
-            WHERE user_id = ?
-            ORDER BY created_at DESC
-            LIMIT 1
-            """,
-            (user_id,)
-        )
-        
-        result = cursor.fetchone()
-        conn.close()
-        
-        return result[0] if result else None
-    
-    def add_summary(self, user_id: str, session_id: str, summary_text: str, message_count: int):
-        """Add AI-generated summary"""
-        try:
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            cursor.execute(
-                """
-                INSERT INTO user_summaries (user_id, session_id, summary_text, message_count)
-                VALUES (?, ?, ?, ?)
-                """,
-                (user_id, session_id, summary_text, message_count)
-            )
-            
-            conn.commit()
-            conn.close()
-            
-            print(f"[Database] ✅ Saved summary for user {user_id} ({message_count} messages)")
-        except Exception as e:
-            print(f"[Database] ❌ Error saving summary: {e}")
-    
-    def close_session(self, session_id: str):
-        """Mark session as inactive"""
-        try:
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            cursor.execute(
-                "UPDATE sessions SET is_active = 0 WHERE session_id = ?",
-                (session_id,)
-            )
-            
-            conn.commit()
-            conn.close()
-        except Exception as e:
-            print(f"[Database] ❌ Error closing session: {e}")
-    
-    def cleanup_old_sessions(self, days: int = 30):
-        """Clean up sessions older than X days"""
-        try:
-            conn = sqlite3.connect(self.db_path)
-            cursor = conn.cursor()
-            
-            cutoff = datetime.now() - timedelta(days=days)
-            
-            cursor.execute(
-                "DELETE FROM sessions WHERE last_activity < ? AND is_active = 0",
-                (cutoff,)
-            )
-            
-            deleted = cursor.rowcount
-            conn.commit()
-            conn.close()
-            
-            if deleted > 0:
-                print(f"[Database] 🗑️ Cleaned up {deleted} old sessions")
-        except Exception as e:
-            print(f"[Database] ❌ Error cleaning sessions: {e}")

mrrrme/utils/weight_finder.py

@@ -1,38 +0,0 @@
-"""Utility for finding OpenFace weight files"""
-import os
-from pathlib import Path
-from glob import glob
-
-
-def find_weight(filename: str) -> str:
-    """Find weight file in various possible locations"""
-    # Check environment variable
-    env_dir = os.environ.get("OPENFACE_WEIGHT_DIR")
-    if env_dir:
-        p = Path(env_dir) / filename
-        if p.is_file():
-            return str(p)
-    
-    # Check package installation
-    try:
-        import openface as _of
-        site_w = Path(_of.__path__[0]) / "weights" / filename
-        if site_w.is_file():
-            return str(site_w)
-    except:
-        pass
-    
-    # Check HuggingFace cache
-    user_home = Path(os.environ.get("USERPROFILE", str(Path.home())))
-    hf_root = user_home / ".cache" / "huggingface" / "hub"
-    if hf_root.exists():
-        hits = glob(str(hf_root / "**" / filename), recursive=True)
-        if hits:
-            return hits[0]
-    
-    # Check local weights directory
-    local = Path("weights") / filename
-    if local.is_file():
-        return str(local)
-    
-    raise FileNotFoundError(f"Weight not found: {filename}")

sync.bat

@@ -1,73 +0,0 @@
-@echo off
-echo ============================================
-echo Nuclear Option: Clean Git History
-echo ============================================
-echo.
-echo WARNING: This will rewrite Git history!
-echo Make sure you have no other important uncommitted changes.
-echo.
-set /p CONFIRM="Type YES to continue: "
-
-if /i NOT "%CONFIRM%"=="YES" (
-    echo Cancelled.
-    pause
-    exit /b
-)
-
-REM Step 1: Remove file from entire Git history
-echo.
-echo Step 1: Removing idle-animation.glb from entire Git history...
-git filter-branch --force --index-filter "git rm --cached --ignore-unmatch avatar-frontend/public/idle-animation.glb" --prune-empty --tag-name-filter cat -- --all
-
-REM Step 2: Clean up
-echo.
-echo Step 2: Cleaning up Git...
-git reflog expire --expire=now --all
-git gc --prune=now --aggressive
-
-REM Step 3: Force push to clear history on both repos
-echo.
-echo Step 3: Force pushing clean history to GitHub...
-git push origin main --force
-
-echo.
-echo Step 4: Force pushing clean history to Hugging Face...
-git push https://huggingface.co/spaces/michon/mrrrme-emotion-ai main --force
-
-REM Step 5: Setup LFS
-echo.
-echo Step 5: Setting up Git LFS...
-git lfs install
-git lfs track "avatar-frontend/public/idle-animation.glb"
-git add .gitattributes
-git commit -m "Setup LFS tracking for animation"
-
-REM Step 6: Push LFS setup
-echo.
-echo Step 6: Pushing LFS setup to GitHub...
-git push origin main
-
-echo.
-echo Step 7: Pushing LFS setup to Hugging Face...
-git push https://huggingface.co/spaces/michon/mrrrme-emotion-ai main
-
-REM Step 7: Add the actual file
-echo.
-echo Step 8: Adding idle-animation.glb with LFS...
-git add avatar-frontend/public/idle-animation.glb
-git commit -m "Add idle animation via LFS (195KB)"
-
-REM Step 8: Push file to both repos
-echo.
-echo Step 9: Pushing to GitHub...
-git push origin main
-
-echo.
-echo Step 10: Pushing to Hugging Face...
-git push https://huggingface.co/spaces/michon/mrrrme-emotion-ai main
-
-echo.
-echo ============================================
-echo Done! File should be accepted now.
-echo ============================================
-pause

weights/ir50.pth

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

weights/mobilefacenet_model_best.pth

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

weights/raf-db-model_best.pth

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