livechat-desktop 1.0.0__tar.gz

livechat_desktop-1.0.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: livechat-desktop
+Version: 1.0.0
+Summary: A desktop overlay for LiveChat built with PyQt6
+Author: Romain Guillon
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6>=6.11.0
+Requires-Dist: python-socketio[client]>=5.11.0
+Requires-Dist: websocket-client>=1.8.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: yt-dlp>=2024.0.0
+Requires-Dist: PyQt6-WebEngine>=6.11.0
+
+# LiveChat Desktop
+
+A desktop client for LiveChat, built with Python and PyQt6.
+
+## Features
+- Displays media from chat using an overlay.
+- Supports generic images/videos, YouTube, TikTok, and Twitter embeds.
+- Customizes overlay sizing automatically.

livechat_desktop-1.0.0/README.md

@@ -0,0 +1,8 @@
+# LiveChat Desktop
+
+A desktop client for LiveChat, built with Python and PyQt6.
+
+## Features
+- Displays media from chat using an overlay.
+- Supports generic images/videos, YouTube, TikTok, and Twitter embeds.
+- Customizes overlay sizing automatically.

livechat_desktop-1.0.0/livechat_desktop/__main__.py

@@ -0,0 +1,36 @@
+import sys
+import os
+import builtins
+
+if os.environ.get("LIVECHAT_DEBUG") != "1":
+    builtins.print = lambda *args, **kwargs: None
+from PyQt6.QtWidgets import QApplication
+
+# Obligatoire pour garantir que Wayland ne capture pas l'overlay et laisse passer les clics
+os.environ['QT_QPA_PLATFORM'] = 'xcb'
+
+from livechat_desktop.socket_manager import SocketManager
+from livechat_desktop.overlay import Overlay
+from livechat_desktop.tray import TrayManager
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # Initialisation des différents modules de l'infrastructure
+    overlay = Overlay()
+    socket_manager = SocketManager()
+    tray_manager = TrayManager(app.style(), socket_manager, overlay)
+    
+    # Connexion des signaux (Events)
+    socket_manager.media_signal.connect(overlay.handle_media)
+    socket_manager.stop_signal.connect(overlay.hide_all)
+    socket_manager.guilds_updated_signal.connect(tray_manager.update_menu)
+    
+    # Démarrage du thread réseau
+    socket_manager.start()
+    
+    # Lancement de la boucle d'événements Qt
+    sys.exit(app.exec())
+
+if __name__ == '__main__':
+    main()

livechat_desktop-1.0.0/livechat_desktop/config.py

@@ -0,0 +1,41 @@
+import os
+import json
+
+CONFIG_PATH = os.path.expanduser("~/.config/livechat-desktop/configLiveChat.json")
+
+class ConfigManager:
+    def __init__(self):
+        self.user_id = None
+        self.active_rooms = set()
+        self.load_config()
+
+    def load_config(self):
+        print("Chemin recherché pour la config :", CONFIG_PATH)
+        if os.path.exists(CONFIG_PATH):
+            try:
+                with open(CONFIG_PATH, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                self.user_id = data.get('userId')
+                self.active_rooms = set(data.get('activeRooms', []))
+                print("Configuration chargée depuis :", CONFIG_PATH)
+            except Exception as e:
+                print("Erreur lors du chargement de la config :", e)
+
+    def save_config(self):
+        os.makedirs(os.path.dirname(CONFIG_PATH), exist_ok=True)
+        try:
+            config = {
+                'userId': self.user_id,
+                'activeRooms': list(self.active_rooms)
+            }
+            with open(CONFIG_PATH, 'w', encoding='utf-8') as f:
+                json.dump(config, f, indent=2)
+            print("Configuration enregistrée à :", CONFIG_PATH)
+        except Exception as e:
+            print("Erreur lors de la sauvegarde de la config :", e)
+
+    def set_user_id(self, user_id):
+        self.user_id = user_id
+        self.save_config()
+
+config_manager = ConfigManager()

livechat_desktop-1.0.0/livechat_desktop/overlay.py

@@ -0,0 +1,333 @@
+import re
+import requests
+from PyQt6.QtCore import Qt, QTimer, QUrl
+from PyQt6.QtWidgets import QMainWindow, QLabel, QVBoxLayout, QWidget, QApplication
+from PyQt6.QtGui import QPixmap
+from PyQt6.QtMultimedia import QMediaPlayer, QAudioOutput
+from PyQt6.QtMultimediaWidgets import QVideoWidget
+from PyQt6.QtWebEngineWidgets import QWebEngineView
+from PyQt6.QtWebEngineCore import QWebEngineSettings
+from livechat_desktop.providers import process_link
+
+class Overlay(QMainWindow):
+    # --- CONFIGURATION & CONSTANTS ---
+    MAX_WIDTH_RATIO = 0.85
+    MEDIA_SCALE_WITH_TEXT = 0.70
+    MEDIA_SCALE_NO_TEXT = 0.85
+    
+    DEFAULT_DURATION_BOT = 2000
+    
+    TEXT_LEN_SHORT = 50
+    TEXT_LEN_MED = 100
+    TEXT_LEN_LONG = 200
+    
+    FONT_SCALE_SHORT = 0.02
+    FONT_SCALE_MED = 0.018
+    FONT_SCALE_LONG = 0.015
+    FONT_SCALE_XLONG = 0.012
+    
+    DEFAULT_WEB_WIDTH = 1280
+    DEFAULT_WEB_HEIGHT = 720
+    
+    BOTTOM_MARGIN = 120 # Remonte le contenu pour ne pas chevaucher la barre des tâches
+
+    def __init__(self):
+        super().__init__()
+        
+        self.setWindowFlags(
+            Qt.WindowType.FramelessWindowHint |
+            Qt.WindowType.WindowStaysOnTopHint |
+            Qt.WindowType.Tool |
+            Qt.WindowType.WindowTransparentForInput
+        )
+        self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        
+        screen = QApplication.primaryScreen().geometry()
+        self.setGeometry(screen)
+        
+        self.central_widget = QWidget()
+        self.setCentralWidget(self.central_widget)
+        
+        self.layout = QVBoxLayout(self.central_widget)
+        self.layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.layout.setContentsMargins(0, 0, 0, self.BOTTOM_MARGIN)
+        
+        self.image_label = QLabel()
+        self.image_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.image_label.hide()
+        
+        self.top_text_label = QLabel()
+        self.top_text_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.top_text_label.hide()
+        
+        self.bottom_text_label = QLabel()
+        self.bottom_text_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.bottom_text_label.hide()
+        
+        self.video_widget = QVideoWidget()
+        self.video_widget.videoSink().videoSizeChanged.connect(self.on_video_size_changed)
+        self.media_player = QMediaPlayer()
+        self.audio_output = QAudioOutput()
+        self.media_player.setAudioOutput(self.audio_output)
+        self.media_player.setVideoOutput(self.video_widget)
+        self.video_widget.hide()
+        
+        # Le navigateur intégré (remplace l'iframe de l'ancien client)
+        self.web_view = QWebEngineView()
+        self.web_view.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
+        self.web_view.page().setBackgroundColor(Qt.GlobalColor.transparent)
+        # Autoriser l'autoplay des vidéos sans interaction utilisateur
+        self.web_view.settings().setAttribute(QWebEngineSettings.WebAttribute.PlaybackRequiresUserGesture, False)
+        self.web_view.hide()
+        self.web_view.loadFinished.connect(self.on_web_load_finished)
+        self.web_view.titleChanged.connect(self.on_title_changed)
+        
+        self.layout.addWidget(self.top_text_label, alignment=Qt.AlignmentFlag.AlignCenter)
+        self.layout.addWidget(self.image_label, alignment=Qt.AlignmentFlag.AlignCenter)
+        self.layout.addWidget(self.video_widget, alignment=Qt.AlignmentFlag.AlignCenter)
+        self.layout.addWidget(self.web_view, alignment=Qt.AlignmentFlag.AlignCenter)
+        self.layout.addWidget(self.bottom_text_label, alignment=Qt.AlignmentFlag.AlignCenter)
+        
+        self.timer = QTimer(self)
+        self.timer.timeout.connect(self.hide_all)
+
+    def _get_text_height(self):
+        h = 0
+        if not self.top_text_label.isHidden():
+            h += self.top_text_label.height() + self.layout.spacing()
+        if not self.bottom_text_label.isHidden():
+            h += self.bottom_text_label.height() + self.layout.spacing()
+        return h
+
+    def _get_media_max_height(self, has_text):
+        is_fullscreen = getattr(self, 'current_format', 'illustration') == 'fullscreen'
+        
+        if is_fullscreen:
+            base_h = self.height() - getattr(self, 'current_bottom_margin', 0)
+        else:
+            base_h = int(self.height() * self.MAX_WIDTH_RATIO) # 85% de l'écran
+            
+        if has_text:
+            return max(100, base_h - self._get_text_height() - 20)
+        return base_h
+
+    def on_video_size_changed(self, size=None):
+        if size is None or not size.isValid():
+            size = self.video_widget.videoSink().videoSize()
+        if size.width() > 0 and size.height() > 0:
+            scale_factor = getattr(self, 'media_scale_factor', self.MEDIA_SCALE_NO_TEXT)
+            has_text = scale_factor != self.MEDIA_SCALE_NO_TEXT
+            
+            is_fullscreen = getattr(self, 'current_format', 'illustration') == 'fullscreen'
+            if is_fullscreen:
+                max_w = self.width()
+            else:
+                max_w = int(self.width() * self.MAX_WIDTH_RATIO)
+                
+            max_h = self._get_media_max_height(has_text)
+                
+            scaled = size.scaled(max_w, max_h, Qt.AspectRatioMode.KeepAspectRatio)
+            self.video_widget.setFixedSize(scaled)
+
+    def on_title_changed(self, title):
+        if title == "VIDEO_ENDED":
+            self.hide_all()
+
+    def on_web_load_finished(self, ok):
+        if not ok: return
+        js_code = getattr(self, 'current_js_injection', None)
+        if js_code:
+            self.web_view.page().runJavaScript(js_code)
+
+
+
+    def hide_all(self):
+        self.timer.stop()
+        self.image_label.hide()
+        self.video_widget.hide()
+        self.top_text_label.hide()
+        self.bottom_text_label.hide()
+        self.web_view.hide()
+        self.web_view.setUrl(QUrl("about:blank"))
+        self.media_player.stop()
+        try:
+            self.media_player.mediaStatusChanged.disconnect(self.on_media_status_changed)
+        except:
+            pass
+        self.hide()
+
+    def play_direct_video(self, direct_url, duration=None):
+        try:
+            self.media_player.setSource(QUrl(direct_url))
+            self.video_widget.show()
+            self.media_player.play()
+            if duration:
+                self.timer.start(duration)
+            else:
+                self.media_player.mediaStatusChanged.connect(self.on_media_status_changed)
+        except Exception as e:
+            print("Erreur lecteur vidéo:", e)
+            
+    def on_media_status_changed(self, status):
+        print(f"DEBUG: Media status changed to {status}")
+        if status == QMediaPlayer.MediaStatus.EndOfMedia:
+            print("DEBUG: EndOfMedia reached, hiding all.")
+            self.hide_all()
+            try:
+                self.media_player.mediaStatusChanged.disconnect(self.on_media_status_changed)
+            except:
+                pass
+
+    def handle_media(self, data):
+        print(f"DEBUG: Media received: {data}")
+        self.hide_all()
+        
+        url = data.get('url')
+        lien = data.get('lien')
+        text = data.get('text')
+        media_type = data.get('type')
+        duration_raw = data.get('duration')
+        try:
+            duration = int(duration_raw) if duration_raw is not None else None
+        except ValueError:
+            duration = None
+        self.current_format = data.get('format', 'illustration')
+        
+        if self.current_format == 'fullscreen':
+            self.current_bottom_margin = 0
+            self.layout.setContentsMargins(0, 0, 0, 0)
+        else:
+            self.current_bottom_margin = self.BOTTOM_MARGIN
+            self.layout.setContentsMargins(0, 0, 0, self.BOTTOM_MARGIN)
+        
+        top_text = None
+        bottom_text = text
+        provider_result = {}
+        
+        # PROCESSEUR DE LIENS (Twitter, YouTube, TikTok...)
+        self.current_js_injection = None
+        if lien:
+            usable_window_size = (self.width(), self.height() - self.current_bottom_margin)
+            provider_result = process_link(lien, data, usable_window_size)
+            self.current_js_injection = provider_result.get("js_injection")
+            
+            # Application des modifs de données (ex: Twitter convertit le lien en url direct media)
+            if "url" in provider_result: url = provider_result["url"]
+            if "type" in provider_result: media_type = provider_result["type"]
+            if "lien" in provider_result: lien = provider_result["lien"]
+            if "top_text" in provider_result: top_text = provider_result["top_text"]
+
+        # --- WORKAROUND ---
+        # Le bot distant (sur iceboxer) envoie par défaut duration=2000 si non précisé.
+        # On l'ignore pour les vidéos et les liens pour les laisser se terminer naturellement.
+        # SAUF pour les pages web génériques où on laisse le timer s'appliquer.
+        is_generic_web = provider_result.get("is_generic_web", False)
+        
+        # Si c'est une page web générique, on s'assure qu'il y a un timer
+        if is_generic_web and not duration:
+            duration = self.DEFAULT_DURATION_BOT
+            
+        if ((lien and not is_generic_web) or media_type in ('video', 'audio')) and duration == self.DEFAULT_DURATION_BOT:
+            duration = None
+            
+        print(f"DEBUG: Processed duration is: {duration}")
+        
+        has_text = bool(top_text or bottom_text)
+        self.media_scale_factor = self.MEDIA_SCALE_WITH_TEXT if has_text else self.MEDIA_SCALE_NO_TEXT
+        
+        def setup_label(label, t):
+            if not t: return
+            
+            # Nettoyage des sauts de ligne inutiles et des espaces multiples
+            t = " ".join(t.split())
+            
+            length = len(t)
+            # Base text sizes on screen width for perfect scaling
+            if length < self.TEXT_LEN_SHORT: fs_factor = self.FONT_SCALE_SHORT
+            elif length < self.TEXT_LEN_MED: fs_factor = self.FONT_SCALE_MED
+            elif length < self.TEXT_LEN_LONG: fs_factor = self.FONT_SCALE_LONG
+            else: fs_factor = self.FONT_SCALE_XLONG
+            
+            font_size = int(self.width() * fs_factor)
+            padding = int(font_size / 3)
+            radius = int(font_size / 4)
+            
+            label.setStyleSheet(f"color: white; font-size: {font_size}px; font-weight: bold; background-color: rgba(0,0,0,150); padding: {padding}px; border-radius: {radius}px;")
+            label.setWordWrap(True)
+            label.setMaximumWidth(int(self.width() * self.MAX_WIDTH_RATIO))
+            label.setText(t)
+            label.adjustSize() # Ensure it calculates its own bounds AFTER text is set
+            label.setMinimumHeight(label.sizeHint().height())
+            label.show()
+
+        setup_label(self.top_text_label, top_text)
+        setup_label(self.bottom_text_label, bottom_text)
+            
+        if lien:
+            embed_url = provider_result.get("embed_url", lien)
+            web_size = provider_result.get("web_size")
+            html = provider_result.get("html")
+            
+            if web_size:
+                max_h = self._get_media_max_height(has_text)
+                is_fullscreen = self.current_format == 'fullscreen'
+                target_w = self.width() if is_fullscreen else int(self.width() * self.MAX_WIDTH_RATIO)
+                
+                if provider_result.get("is_generic_web", False):
+                    # La page web générique prend tout l'espace ciblé
+                    self.web_view.setFixedSize(target_w, max_h)
+                else:
+                    if web_size[1] > 0:
+                        ratio = web_size[0] / web_size[1]
+                        if abs(web_size[0] - self.width()) < 10: 
+                            self.web_view.setFixedSize(target_w, max_h)
+                        else:
+                            new_w = int(max_h * ratio)
+                            # S'assurer de ne pas dépasser la largeur cible
+                            if new_w > target_w:
+                                new_w = target_w
+                                max_h = int(new_w / ratio)
+                            self.web_view.setFixedSize(new_w, max_h)
+                    else:
+                        self.web_view.setFixedSize(target_w, max_h)
+            else:
+                self.web_view.setFixedSize(self.DEFAULT_WEB_WIDTH, self.DEFAULT_WEB_HEIGHT)
+                
+            if html:
+                self.web_view.setHtml(html, QUrl("http://localhost"))
+            else:
+                self.web_view.setUrl(QUrl(embed_url))
+                
+            self.web_view.show()
+            if duration:
+                self.timer.start(duration)
+            
+        elif url:
+            if media_type == 'image':
+                try:
+                    resp = requests.get(url)
+                    if resp.status_code == 200:
+                        pixmap = QPixmap()
+                        pixmap.loadFromData(resp.content)
+                        scale_factor = getattr(self, 'media_scale_factor', self.MEDIA_SCALE_NO_TEXT)
+                        has_text = scale_factor != self.MEDIA_SCALE_NO_TEXT
+                        max_h = self._get_media_max_height(has_text)
+                        
+                        is_fullscreen = self.current_format == 'fullscreen'
+                        target_w = self.width() if is_fullscreen else int(self.width() * self.MAX_WIDTH_RATIO)
+                        
+                        scaled_pix = pixmap.scaled(target_w, max_h, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
+                        self.image_label.setPixmap(scaled_pix)
+                        self.image_label.show()
+                except Exception as e:
+                    print("Error image:", e)
+            elif media_type in ('video', 'audio'):
+                self.play_direct_video(url, duration)
+        
+        if not lien and media_type not in ('video', 'audio'):
+            if duration:
+                self.timer.start(duration)
+            elif media_type == 'image' or text:
+                pass
+            
+        self.show()

livechat_desktop-1.0.0/livechat_desktop/providers/__init__.py

@@ -0,0 +1,27 @@
+from .twitter import TwitterProvider
+from .youtube import YouTubeProvider
+from .tiktok import TikTokProvider
+from .generic import GenericProvider
+
+# Initialisation des providers dans l'ordre de priorité
+PROVIDERS = [
+    TwitterProvider(),
+    YouTubeProvider(),
+    TikTokProvider(),
+    GenericProvider() # Fallback qui gère tout ou presque
+]
+
+def process_link(lien, data, window_size):
+    """
+    Routage vers le bon provider selon l'URL.
+    Retourne un dictionnaire contenant les modifications de 'data' ou 
+    des instructions spécifiques de rendu (html, embed_url, web_size).
+    """
+    if not lien:
+        return {}
+        
+    for provider in PROVIDERS:
+        if provider.can_handle(lien):
+            return provider.process(lien, data, window_size)
+            
+    return {}

livechat_desktop-1.0.0/livechat_desktop/providers/base.py

@@ -0,0 +1,17 @@
+class MediaProvider:
+    """
+    Classe de base (interface) pour tous les fournisseurs de médias.
+    Normalise le traitement des liens entrants.
+    """
+    
+    def can_handle(self, url: str) -> bool:
+        """Retourne True si ce fournisseur peut gérer l'URL donnée."""
+        raise NotImplementedError("doit être implémenté par la classe fille")
+
+    def process(self, url: str, data: dict, window_size: tuple) -> dict:
+        """
+        Traite l'URL et retourne un dictionnaire contenant les instructions 
+        de rendu (embed_url, html, web_size, js_injection, etc.) ou les 
+        modifications à apporter à l'objet `data` (url, type, etc.).
+        """
+        raise NotImplementedError("doit être implémenté par la classe fille")

livechat_desktop-1.0.0/livechat_desktop/providers/generic.py

@@ -0,0 +1,19 @@
+from .base import MediaProvider
+
+class GenericProvider(MediaProvider):
+    GENERIC_WEB_WIDTH_RATIO = 0.85
+    GENERIC_WEB_HEIGHT_RATIO = 0.85
+
+    def can_handle(self, url: str) -> bool:
+        return True # Fallback for everything else
+
+    def process(self, url: str, data: dict, window_size: tuple) -> dict:
+        max_w = int(window_size[0] * self.GENERIC_WEB_WIDTH_RATIO)
+        max_h = int(window_size[1] * self.GENERIC_WEB_HEIGHT_RATIO)
+        
+        return {
+            "type": "web",
+            "embed_url": url,
+            "web_size": (max_w, max_h),
+            "is_generic_web": True
+        }

livechat_desktop-1.0.0/livechat_desktop/providers/scripts/tiktok_bypass.js

@@ -0,0 +1,27 @@
+// Masquer les bandeaux avec CSS au cas où on n'arrive pas à cliquer
+const style = document.createElement('style');
+style.innerHTML = '.tiktok-cookie-banner, [data-testid="CookieConsent"], ytd-consent-bump-v2-lightbox, .tp-yt-paper-dialog { display: none !important; }';
+document.head.appendChild(style);
+
+// Boucle agressive pour cliquer sur les popups asynchrones
+let attempts = 0;
+const intervalId = setInterval(() => {
+    attempts++;
+    // On cherche tous les éléments cliquables
+    document.querySelectorAll('button, a, div[role="button"]').forEach(btn => {
+        const text = (btn.innerText || '').toLowerCase();
+        if (text.includes('allow all') || text.includes('tout accepter') || 
+            text.includes('decline') || text.includes('refuser') || text.includes('accepter cookies')) {
+            btn.click();
+        }
+    });
+    
+    // Clic sur Play
+    const playBtn = document.querySelector('.xgplayer-play, .play-button, button[aria-label="Play"], button[aria-label="Watch"]');
+    if (playBtn) { 
+        playBtn.click(); 
+    }
+    
+    // On arrête de spammer après 20 essais (10 secondes)
+    if (attempts > 20) clearInterval(intervalId);
+}, 500);

livechat_desktop-1.0.0/livechat_desktop/providers/scripts/youtube_embed.html

@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <style>
+        body, html { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background-color: transparent; }
+        iframe { width: 100%; height: 100%; border: none; }
+    </style>
+</head>
+<body>
+    <iframe id="player" src="{embed_url}" allow="autoplay; fullscreen" referrerpolicy="strict-origin-when-cross-origin"></iframe>
+    <script>
+        var iframe = document.getElementById("player");
+        iframe.onload = function() {
+            iframe.contentWindow.postMessage('{"event":"listening","id":1}', '*');
+        };
+        window.addEventListener("message", function(event) {
+            try {
+                var data = JSON.parse(event.data);
+                // YT.PlayerState.ENDED == 0
+                if (data.event === "infoDelivery" && data.info && data.info.playerState === 0) {
+                    document.title = "VIDEO_ENDED";
+                }
+                if (data.event === "onStateChange" && data.info === 0) {
+                    document.title = "VIDEO_ENDED";
+                }
+            } catch(e) {}
+        });
+    </script>
+</body>
+</html>

livechat_desktop-1.0.0/livechat_desktop/providers/tiktok.py

@@ -0,0 +1,41 @@
+import re
+import os
+from .base import MediaProvider
+
+class TikTokProvider(MediaProvider):
+    TIKTOK_URL_REGEX = r'tiktok\.com\/.*\/video\/([0-9]+)'
+    TIKTOK_EMBED_BASE = "https://www.tiktok.com/embed/v2/"
+    TIKTOK_ASPECT_RATIO = 9 / 16
+    TIKTOK_DEFAULT_WIDTH = 405
+    TIKTOK_DEFAULT_HEIGHT = 720
+
+    def __init__(self):
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        script_path = os.path.join(script_dir, 'scripts', 'tiktok_bypass.js')
+        with open(script_path, 'r', encoding='utf-8') as f:
+            self.js_bypass_script = f.read()
+
+    def can_handle(self, url: str) -> bool:
+        return bool(re.search(self.TIKTOK_URL_REGEX, url))
+
+    def process(self, url: str, data: dict, window_size: tuple) -> dict:
+        match = re.search(self.TIKTOK_URL_REGEX, url)
+        if not match:
+            return {}
+            
+        video_id = match.group(1)
+        embed_url = f"{self.TIKTOK_EMBED_BASE}{video_id}"
+        
+        current_format = data.get('format', 'illustration')
+        if current_format == "fullscreen":
+            h = window_size[1]
+            w = int(h * self.TIKTOK_ASPECT_RATIO)
+            web_size = (w, h)
+        else:
+            web_size = (self.TIKTOK_DEFAULT_WIDTH, self.TIKTOK_DEFAULT_HEIGHT)
+            
+        return {
+            "embed_url": embed_url,
+            "web_size": web_size,
+            "js_injection": self.js_bypass_script
+        }

livechat_desktop-1.0.0/livechat_desktop/providers/twitter.py

@@ -0,0 +1,45 @@
+import re
+import requests
+from .base import MediaProvider
+
+class TwitterProvider(MediaProvider):
+    TWITTER_URL_REGEX = r'(?:twitter\.com|x\.com)\/[^\/]+\/status\/(\d+)'
+    FXTWITTER_API_BASE = "https://api.fxtwitter.com/status/"
+    API_TIMEOUT = 5
+
+    def can_handle(self, url: str) -> bool:
+        return "x.com" in url or "twitter.com" in url
+
+    def process(self, url: str, data: dict, window_size: tuple) -> dict:
+        match = re.search(self.TWITTER_URL_REGEX, url)
+        if not match:
+            return {}
+
+        tweet_id = match.group(1)
+        result = {}
+        
+        try:
+            resp = requests.get(f"{self.FXTWITTER_API_BASE}{tweet_id}", timeout=self.API_TIMEOUT)
+            if resp.status_code == 200:
+                api_data = resp.json()
+                tweet = api_data.get("tweet", {})
+                if not tweet:
+                    return {}
+                    
+                xt_text = tweet.get("text")
+                if xt_text:
+                    result["top_text"] = xt_text
+                    
+                media = tweet.get("media", {}).get("all", [])
+                if media:
+                    first_media = media[0]
+                    m_type = "video" if first_media.get("type") in ("video", "gif") else "image"
+                    m_url = first_media.get("url")
+                    
+                    result["url"] = m_url
+                    result["type"] = m_type
+                    result["lien"] = None
+        except Exception as e:
+            print("Erreur extraction Twitter:", e)
+            
+        return result

livechat_desktop-1.0.0/livechat_desktop/providers/youtube.py

@@ -0,0 +1,40 @@
+import re
+import os
+from .base import MediaProvider
+
+class YouTubeProvider(MediaProvider):
+    YOUTUBE_URL_REGEX = r'(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})'
+    YOUTUBE_EMBED_BASE = "https://www.youtube-nocookie.com/embed/"
+    YOUTUBE_EMBED_PARAMS = "?autoplay=1&controls=0&showinfo=0&rel=0&iv_load_policy=3&enablejsapi=1"
+    YOUTUBE_DEFAULT_WIDTH = 1280
+    YOUTUBE_DEFAULT_HEIGHT = 720
+
+    def __init__(self):
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        template_path = os.path.join(script_dir, 'scripts', 'youtube_embed.html')
+        with open(template_path, 'r', encoding='utf-8') as f:
+            self.youtube_html_template = f.read()
+
+    def can_handle(self, url: str) -> bool:
+        return bool(re.search(self.YOUTUBE_URL_REGEX, url))
+
+    def process(self, url: str, data: dict, window_size: tuple) -> dict:
+        match = re.search(self.YOUTUBE_URL_REGEX, url)
+        if not match:
+            return {}
+            
+        video_id = match.group(1)
+        embed_url = f"{self.YOUTUBE_EMBED_BASE}{video_id}{self.YOUTUBE_EMBED_PARAMS}"
+        html = self.youtube_html_template.replace("{embed_url}", embed_url)
+        
+        current_format = data.get('format', 'illustration')
+        if current_format == "fullscreen":
+            web_size = (window_size[0], window_size[1])
+        else:
+            web_size = (self.YOUTUBE_DEFAULT_WIDTH, self.YOUTUBE_DEFAULT_HEIGHT)
+            
+        return {
+            "embed_url": embed_url,
+            "html": html,
+            "web_size": web_size
+        }

livechat_desktop-1.0.0/livechat_desktop/socket_manager.py

@@ -0,0 +1,77 @@
+import os
+import socketio
+from PyQt6.QtCore import QThread, pyqtSignal
+from livechat_desktop.config import config_manager
+
+class SocketManager(QThread):
+    # Signaux pour communiquer avec l'interface graphique (Overlay)
+    media_signal = pyqtSignal(dict)
+    stop_signal = pyqtSignal()
+    guilds_updated_signal = pyqtSignal(list)
+    
+    def __init__(self):
+        super().__init__()
+        self.sio = socketio.Client()
+        self.bot_client_id = None
+        self.client_guilds = []
+        
+        self.setup_events()
+
+    def setup_events(self):
+        @self.sio.on('connect')
+        def on_connect():
+            print("Connecté au serveur Socket")
+            print("Vérification de user_id :", config_manager.user_id)
+            if config_manager.user_id:
+                print("Envoi de get-my-guilds avec l'id :", config_manager.user_id)
+                self.get_my_guilds()
+            else:
+                print("Aucun user_id trouvé dans config_manager!")
+
+        @self.sio.on('bot-config')
+        def on_bot_config(config):
+            print("Config reçue du bot :", config)
+            self.bot_client_id = config.get('clientId')
+            self.guilds_updated_signal.emit(self.client_guilds)
+
+        @self.sio.on('list-guilds')
+        def on_list_guilds(guilds):
+            print(f"Liste des serveurs reçue ({len(guilds)} serveurs)")
+            self.client_guilds = guilds
+            
+            # On rejoint les rooms actives
+            for room_id in list(config_manager.active_rooms):
+                if any(g.get('id') == room_id for g in guilds):
+                    print(f"Rejoint la room active : {room_id}")
+                    self.join_room(room_id)
+                else:
+                    config_manager.active_rooms.remove(room_id)
+            
+            config_manager.save_config()
+            self.guilds_updated_signal.emit(self.client_guilds)
+
+        @self.sio.on('display-media')
+        def on_display_media(data):
+            self.media_signal.emit(data)
+            
+        @self.sio.on('stop')
+        def on_stop():
+            self.stop_signal.emit()
+
+    def get_my_guilds(self):
+        if config_manager.user_id:
+            self.sio.emit("get-my-guilds", config_manager.user_id)
+
+    def join_room(self, guild_id):
+        self.sio.emit("join-server-room", guild_id)
+
+    def leave_room(self, guild_id):
+        self.sio.emit("leave-server-room", guild_id)
+
+    def run(self):
+        socket_url = os.environ.get("SOCKET_URL", "http://iceboxer.hd.free.fr:8080")
+        try:
+            self.sio.connect(socket_url)
+            self.sio.wait()
+        except Exception as e:
+            print("SocketIO Error:", e)

livechat_desktop-1.0.0/livechat_desktop/tray.py

@@ -0,0 +1,94 @@
+import os
+import webbrowser
+import urllib.parse
+from PyQt6.QtWidgets import QSystemTrayIcon, QMenu, QApplication
+from PyQt6.QtGui import QAction, QIcon
+from livechat_desktop.config import config_manager
+
+class TrayManager:
+    def __init__(self, style, socket_manager, overlay):
+        self.tray_icon = QSystemTrayIcon()
+        
+        # Load custom icon if available
+        icon_path = os.path.join(os.path.dirname(__file__), 'assets', 'icons', 'romain_guillon.jpg')
+        if os.path.exists(icon_path):
+            self.tray_icon.setIcon(QIcon(icon_path))
+        else:
+            # Fallback system icon
+            self.tray_icon.setIcon(style.standardIcon(style.StandardPixmap.SP_ComputerIcon))
+        
+        self.menu = QMenu()
+        self.tray_icon.setContextMenu(self.menu)
+        
+        self.socket_manager = socket_manager
+        self.overlay = overlay
+        
+        self.update_menu([])
+        self.tray_icon.show()
+
+    def update_menu(self, guilds):
+        self.menu.clear()
+        
+        # User status
+        status_text = f"Connecté: {config_manager.user_id}" if config_manager.user_id else "Non connecté"
+        action_status = self.menu.addAction(status_text)
+        action_status.setEnabled(True)  # GNOME masque parfois les éléments désactivés
+        
+        if not config_manager.user_id and self.socket_manager.bot_client_id:
+            action_login = self.menu.addAction("Se connecter à Discord")
+            action_login.triggered.connect(self.login_discord)
+            
+        if config_manager.user_id:
+            action_refresh = self.menu.addAction("Recharger la liste des serveurs")
+            action_refresh.triggered.connect(self.socket_manager.get_my_guilds)
+            
+            action_logout = self.menu.addAction("Se déconnecter")
+            action_logout.triggered.connect(self.logout)
+            
+        self.menu.addSeparator()
+        
+        action_rooms = self.menu.addAction("Rooms disponibles :")
+        action_rooms.setEnabled(True)
+        
+        if not guilds:
+            label = self.menu.addAction("Aucune room disponible")
+            label.setEnabled(True)
+        else:
+            for guild in guilds:
+                guild_id = guild.get('id')
+                action = QAction(guild.get('name', 'Serveur inconnu'), self.menu)
+                action.setCheckable(True)
+                action.setChecked(guild_id in config_manager.active_rooms)
+                # On utilise lambda avec paramètre par défaut pour figer la valeur de guild_id
+                action.triggered.connect(lambda checked, gid=guild_id: self.toggle_room(gid))
+                self.menu.addAction(action)
+                
+        self.menu.addSeparator()
+        
+        quit_action = QAction("Quitter LiveChat Python", self.menu)
+        quit_action.triggered.connect(QApplication.instance().quit)
+        self.menu.addAction(quit_action)
+
+    def login_discord(self):
+        redirect_uri = urllib.parse.quote("http://iceboxer.hd.free.fr:8080/callback")
+        auth_url = f"https://discord.com/api/oauth2/authorize?client_id={self.socket_manager.bot_client_id}&redirect_uri={redirect_uri}&response_type=code&scope=identify%20guilds"
+        webbrowser.open(auth_url)
+
+    def logout(self):
+        config_manager.set_user_id(None)
+        config_manager.active_rooms.clear()
+        config_manager.save_config()
+        self.socket_manager.client_guilds = []
+        self.update_menu([])
+
+    def toggle_room(self, guild_id):
+        if guild_id in config_manager.active_rooms:
+            config_manager.active_rooms.remove(guild_id)
+            self.socket_manager.leave_room(guild_id)
+        else:
+            config_manager.active_rooms.add(guild_id)
+            self.socket_manager.join_room(guild_id)
+        
+        config_manager.save_config()
+        # Rafraîchir le menu pour mettre à jour les cases cochées
+        self.update_menu(self.socket_manager.client_guilds)

livechat_desktop-1.0.0/livechat_desktop.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: livechat-desktop
+Version: 1.0.0
+Summary: A desktop overlay for LiveChat built with PyQt6
+Author: Romain Guillon
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: PyQt6>=6.11.0
+Requires-Dist: python-socketio[client]>=5.11.0
+Requires-Dist: websocket-client>=1.8.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: yt-dlp>=2024.0.0
+Requires-Dist: PyQt6-WebEngine>=6.11.0
+
+# LiveChat Desktop
+
+A desktop client for LiveChat, built with Python and PyQt6.
+
+## Features
+- Displays media from chat using an overlay.
+- Supports generic images/videos, YouTube, TikTok, and Twitter embeds.
+- Customizes overlay sizing automatically.

livechat_desktop-1.0.0/livechat_desktop.egg-info/SOURCES.txt

@@ -0,0 +1,31 @@
+README.md
+pyproject.toml
+livechat_desktop/__main__.py
+livechat_desktop/config.py
+livechat_desktop/overlay.py
+livechat_desktop/socket_manager.py
+livechat_desktop/tray.py
+livechat_desktop.egg-info/PKG-INFO
+livechat_desktop.egg-info/SOURCES.txt
+livechat_desktop.egg-info/dependency_links.txt
+livechat_desktop.egg-info/entry_points.txt
+livechat_desktop.egg-info/requires.txt
+livechat_desktop.egg-info/top_level.txt
+livechat_desktop/assets/icons/romain_guillon.jpg
+livechat_desktop/providers/__init__.py
+livechat_desktop/providers/base.py
+livechat_desktop/providers/generic.py
+livechat_desktop/providers/tiktok.py
+livechat_desktop/providers/twitter.py
+livechat_desktop/providers/youtube.py
+livechat_desktop/providers/scripts/tiktok_bypass.js
+livechat_desktop/providers/scripts/youtube_embed.html
+tests/test_handle.py
+tests/test_image_resize.py
+tests/test_logic.py
+tests/test_overlay_logic.py
+tests/test_timer.py
+tests/test_vxt.py
+tests/test_webview.py
+tests/test_webview2.py
+tests/test_ytdlp.py

livechat_desktop-1.0.0/livechat_desktop.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

livechat_desktop-1.0.0/livechat_desktop.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[gui_scripts]
+livechat-desktop = livechat_desktop.__main__:main

livechat_desktop-1.0.0/livechat_desktop.egg-info/requires.txt

@@ -0,0 +1,6 @@
+PyQt6>=6.11.0
+python-socketio[client]>=5.11.0
+websocket-client>=1.8.0
+requests>=2.32.0
+yt-dlp>=2024.0.0
+PyQt6-WebEngine>=6.11.0

livechat_desktop-1.0.0/livechat_desktop.egg-info/top_level.txt

@@ -0,0 +1 @@
+livechat_desktop

livechat_desktop-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "livechat-desktop"
+version = "1.0.0"
+description = "A desktop overlay for LiveChat built with PyQt6"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "MIT"}
+authors = [
+  {name = "Romain Guillon"}
+]
+dependencies = [
+    "PyQt6>=6.11.0",
+    "python-socketio[client]>=5.11.0",
+    "websocket-client>=1.8.0",
+    "requests>=2.32.0",
+    "yt-dlp>=2024.0.0",
+    "PyQt6-WebEngine>=6.11.0"
+]
+
+[project.gui-scripts]
+livechat-desktop = "livechat_desktop.__main__:main"
+
+[tool.setuptools]
+packages = ["livechat_desktop", "livechat_desktop.providers", "livechat_desktop.assets.icons", "livechat_desktop.providers.scripts"]
+
+[tool.setuptools.package-data]
+livechat_desktop = ["assets/icons/*", "providers/scripts/*"]

livechat_desktop-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

livechat_desktop-1.0.0/tests/test_handle.py

@@ -0,0 +1,35 @@
+import json
+
+def run_test():
+    data = {'url': None, 'type': 'image', 'format': 'illustration', 'duration': 2000, 'text': 'dfrge', 'lien': 'https://store.steampowered.com/app/2445980/GRebels/'}
+    
+    url = data.get('url')
+    lien = data.get('lien')
+    text = data.get('text')
+    media_type = data.get('type')
+    duration_raw = data.get('duration')
+    try:
+        duration = int(duration_raw) if duration_raw is not None else None
+    except ValueError:
+        duration = None
+
+    provider_result = {}
+    if lien:
+        # simulate process_link
+        provider_result = {'type': 'web', 'embed_url': 'https://store.steampowered.com/app/2445980/GRebels/', 'web_size': (1632, 918), 'is_generic_web': True}
+        
+        if "url" in provider_result: url = provider_result["url"]
+        if "type" in provider_result: media_type = provider_result["type"]
+        if "lien" in provider_result: lien = provider_result["lien"]
+        if "top_text" in provider_result: top_text = provider_result["top_text"]
+
+    is_generic_web = provider_result.get("is_generic_web", False)
+    if is_generic_web and not duration:
+        duration = 2000
+        
+    if ((lien and not is_generic_web) or media_type in ('video', 'audio')) and duration == 2000:
+        duration = None
+        
+    print(f"DEBUG: Processed duration is: {duration}")
+
+run_test()

livechat_desktop-1.0.0/tests/test_image_resize.py

@@ -0,0 +1 @@
+# Just to be completely sure about image_label size, we don't need to change it if it's already transparent

livechat_desktop-1.0.0/tests/test_logic.py

@@ -0,0 +1,13 @@
+def test():
+    lien = "https://store.steampowered.com/"
+    media_type = "web"
+    is_generic_web = True
+    duration = 2000
+    DEFAULT_DURATION_BOT = 2000
+    
+    if ((lien and not is_generic_web) or media_type in ('video', 'audio')) and duration == DEFAULT_DURATION_BOT:
+        duration = None
+        
+    print("Duration:", duration)
+
+test()

livechat_desktop-1.0.0/tests/test_overlay_logic.py

@@ -0,0 +1,15 @@
+import sys
+from PyQt6.QtWidgets import QApplication
+from livechat_desktop.overlay import Overlay
+
+app = QApplication(sys.argv)
+o = Overlay()
+data = {'url': None, 'type': 'image', 'format': 'illustration', 'duration': 2000, 'text': 'dfrge', 'lien': 'https://store.steampowered.com/app/2445980/GRebels/'}
+# We just want to see the prints up to Processed duration
+o.hide_all = lambda: None
+o.show = lambda: None
+o.timer.start = lambda d: print(f"Timer started with {d}")
+try:
+    o.handle_media(data)
+except Exception as e:
+    print(e)

livechat_desktop-1.0.0/tests/test_timer.py

@@ -0,0 +1,9 @@
+from PyQt6.QtCore import QTimer, QCoreApplication
+import sys
+app = QCoreApplication(sys.argv)
+t = QTimer()
+try:
+    t.start("2000")
+    print("Success")
+except Exception as e:
+    print("Error:", repr(e))

livechat_desktop-1.0.0/tests/test_vxt.py

@@ -0,0 +1,24 @@
+import requests
+import json
+import re
+
+url = "https://x.com/SpaceX/status/1768273641756557454"
+# Extract ID
+match = re.search(r'(?:twitter\.com|x\.com)\/[^\/]+\/status\/(\d+)', url)
+if match:
+    tweet_id = match.group(1)
+    # try fxtwitter API
+    try:
+        api_url = f"https://api.fxtwitter.com/status/{tweet_id}"
+        resp = requests.get(api_url, timeout=5)
+        print("fxtwitter:", resp.text)
+    except Exception as e:
+        print("fxtwitter err:", e)
+        
+    # try vxtwitter API
+    try:
+        api_url = f"https://api.vxtwitter.com/status/{tweet_id}"
+        resp = requests.get(api_url, timeout=5)
+        print("vxtwitter:", resp.text)
+    except Exception as e:
+        print("vxtwitter err:", e)

livechat_desktop-1.0.0/tests/test_webview.py

@@ -0,0 +1,36 @@
+import sys
+from PyQt6.QtCore import QTimer, QUrl, Qt
+from PyQt6.QtWidgets import QApplication, QMainWindow
+from PyQt6.QtWebEngineWidgets import QWebEngineView
+
+class Overlay(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.web_view = QWebEngineView(self)
+        self.setCentralWidget(self.web_view)
+        self.timer = QTimer(self)
+        self.timer.timeout.connect(self.hide_all)
+        self.web_view.loadFinished.connect(self.on_load)
+        
+    def hide_all(self):
+        print("HIDE ALL CALLED")
+        self.timer.stop()
+        self.web_view.hide()
+        self.web_view.setUrl(QUrl("about:blank"))
+        self.hide()
+        QApplication.quit()
+
+    def show_url(self, url):
+        print("SHOW URL CALLED")
+        self.web_view.setUrl(QUrl(url))
+        self.web_view.show()
+        self.show()
+        self.timer.start(2000)
+        
+    def on_load(self, ok):
+        print("LOAD FINISHED", ok)
+
+app = QApplication(sys.argv)
+o = Overlay()
+o.show_url("https://wikipedia.org")
+sys.exit(app.exec())

livechat_desktop-1.0.0/tests/test_webview2.py

@@ -0,0 +1,37 @@
+import sys
+from PyQt6.QtCore import QTimer, QUrl, Qt
+from PyQt6.QtWidgets import QApplication, QMainWindow
+from PyQt6.QtWebEngineWidgets import QWebEngineView
+
+class Overlay(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.web_view = QWebEngineView(self)
+        self.setCentralWidget(self.web_view)
+        self.timer = QTimer(self)
+        self.timer.timeout.connect(self.hide_all)
+        self.web_view.loadFinished.connect(self.on_load)
+        
+    def hide_all(self):
+        print("HIDE ALL CALLED")
+        self.timer.stop()
+        self.web_view.hide()
+        self.web_view.setUrl(QUrl("about:blank"))
+        self.hide()
+        # Don't quit, let's see if it shows up again
+        QTimer.singleShot(2000, lambda: QApplication.quit())
+
+    def show_url(self, url):
+        print("SHOW URL CALLED")
+        self.web_view.setUrl(QUrl(url))
+        self.web_view.show()
+        self.show()
+        self.timer.start(2000)
+        
+    def on_load(self, ok):
+        print("LOAD FINISHED", ok)
+
+app = QApplication(sys.argv)
+o = Overlay()
+o.show_url("https://wikipedia.org")
+sys.exit(app.exec())

livechat_desktop-1.0.0/tests/test_ytdlp.py

@@ -0,0 +1,27 @@
+import yt_dlp
+import json
+import sys
+
+ydl_opts = {
+    'quiet': True,
+    'extract_flat': False,
+    'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best', # Preferred format for QMediaPlayer
+}
+
+try:
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info("https://www.youtube.com/watch?v=jNQXAC9IVRw", download=False)
+        # It could be in 'url' or we have to pick from 'formats'
+        video_url = info.get('url')
+        if not video_url and 'formats' in info:
+            # find best format that has both video and audio or just the best one
+            for f in reversed(info['formats']):
+                if f.get('vcodec') != 'none' and f.get('acodec') != 'none':
+                    video_url = f.get('url')
+                    break
+            if not video_url:
+                video_url = info['formats'][-1].get('url')
+                
+        print(json.dumps({'title': info.get('title'), 'description': info.get('description'), 'url': video_url}))
+except Exception as e:
+    print(f"Error: {e}")