mwn

Ce qui tourne, ce qui a été essayé, ce qui est en pause.

Huit expériences ouvertes en coupe : la surface quand elle existe, un extrait du vrai code, les modules du dépôt, les services appelés. Chaque statut est le vrai.

La famille G2

G2 se lit « Go to ». Quatre outils vidéo sur le même socle Telegram, de l'écriture d'un script à la publication, et un cousin qui écoute une blockchain.

  1. LAB/012025-2026En cours

    G2tiktokWork, l'usine à vidéos

    Un script envoyé sur Telegram ressort en vidéo verticale montée, doublée et sous-titrée mot à mot, prête à publier.

    L0 · Surface
    Page de présentation de G2tiktokWork : « Tes pires anecdotes de boulot. En millions de vues. », avec l'accès au bot Telegram.
    Image extraite d'une vidéo produite par G2tiktokWork : format vertical, sous-titres karaoké mot à mot sur un fond vidéo.
    L1 · Codemodules/transcriber.py
    heard = [_normalize(w["word"]) for w in words]
    target = [_normalize(t) for t in ref_tokens]
    matcher = difflib.SequenceMatcher(a=heard, b=target, autojunk=False)
    for tag, i1, i2, j1, j2 in matcher.get_opcodes():
        count = j2 - j1
        if count == 0:
            continue  # Whisper a entendu des mots absents du script.
        if tag == "equal":
            for k in range(count):
                aligned.append(
                    {
                        "word": ref_tokens[j1 + k],
                        "start": words[i1 + k]["start"],
                        "end": words[i1 + k]["end"],
                    }
                )
    L2 · Modules
    • main.pyBot Telegram : menu, métiers, comptes, import rapide
    • modules/ai_generator.pyScript et accroche OpenAI, voix ElevenLabs avec repli
    • modules/transcriber.pyWhisper mot à mot, aligné sur le script
    • modules/media_sourcing.pyRushs libres de droits par mots-clés
    • modules/video_processor.pyPlan de coupe calé sur les silences de la voix
    • modules/visual_effects.pySous-titres ASS karaoké, musique, rendu FFmpeg
    L3 · Services
    • Telegram Bot APIInterface, comptes et crédits
    • OpenAIGénération du script et de l'accroche
    • ElevenLabsVoix de synthèse, repli edge-tts
    • Pexels / PixabayBanques de rushs libres de droits
    • FFmpegMontage et rendu 1080×1920
    1. L0SurfaceCapture réelle
    2. L1CodeAligner les mots entendus par Whisper sur le script
    3. L2Modules6 fichiers du dépôt
    4. L3Services5 services appelés

    Conception et développement, seul

    G2 se lit « Go to ». G2tiktokWork est la pièce centrale de la famille : un bot Telegram auquel on donne une niche et une idée, et qui rend une vidéo 1080×1920 terminée. Entre les deux, une chaîne Python : script et accroche générés, voix de synthèse ElevenLabs avec repli local, fond vidéo libre de droits choisi par mots-clés, transcription par Whisper pour caler chaque mot des sous-titres, montage au tempo et rendu par FFmpeg.

    Dans Telegram, le menu tient en quatre boutons : Mes Métiers, Nouveau Métier, Mon Compte, Import Rapide. Chaque niche a sa configuration en JSON : voix, fourchette de prix, rushs propres. Les utilisateurs ont des comptes et des crédits en SQLite, sauvegardés chaque jour ; l'historique des rendus et des accroches déjà utilisées évite de produire deux fois la même chose.

    État réel : en service, une soixantaine de vidéos rendues. La publication reste manuelle : c'est le rôle de G2TiktokAutopost.

    Python, python-telegram-bot, OpenAI, ElevenLabs, faster-whisper, MoviePy, FFmpeg

  2. LAB/022025-2026En cours

    G2Tiktok, le découpeur

    Une vidéo longue entre, des clips 9:16 sous-titrés sortent, vendus en crédits directement dans Telegram.

    L0 · Surface
    Page de présentation du bot G2Tiktok : découpage automatique de vidéos longues en clips verticaux.
    L1 · Codecore/database.py
    def check_download_limit(user_id):
        user = get_user(user_id)
        if user["is_premium"]:
            return True, "Premium"
        count = user["free_downloads_count"] or 0
        last_reset = user["last_download_reset"]
        now = datetime.now()
        if last_reset:
            last_reset_dt = datetime.fromisoformat(last_reset)
            if (now - last_reset_dt).total_seconds() > 5 * 3600:
                count = 0
                # ... remise à zéro écrite en base
        if count < 3:
            return True, f"Free ({count+1}/3)"
        return False, "Limite atteinte (3 clips / 5h)."
    L2 · Modules
    • bot/handlers/processing.pyReçoit le lien, lance le découpage, renvoie les clips
    • bot/services/queue_manager.pyFile par utilisateur, priorité, débit des crédits
    • bot/services/uploader.pyEnvoi MTProto des fichiers lourds via Pyrogram
    • core/splitter.pyRecadrage 9:16 sur fond flouté, sous-titres, rendu
    • core/analyzer.pyRepérage des segments qui tiennent seuls
    • core/database.pyUtilisateurs, crédits, abonnements, limites
    L3 · Services
    • Telegram Bot APIInterface, paiements en Telegram Stars
    • Telegram MTProto (Pyrogram)Fichiers jusqu'à deux gigaoctets
    • yt-dlpTéléchargement YouTube, TikTok, Instagram
    • Google GeminiAnalyse de la vidéo et choix des segments
    • FFmpegRecadrage, flou, sous-titres, encodage
    1. L0SurfaceCapture réelle
    2. L1CodeLimite gratuite : trois clips par fenêtre de cinq heures
    3. L2Modules6 fichiers du dépôt
    4. L3Services5 services appelés

    Conception et développement, seul

    Le second membre de la famille prend le problème à l'envers : la matière existe déjà, sous forme de vidéo longue (YouTube, TikTok, Instagram). Le bot la télécharge, repère les segments qui tiennent seuls, les recadre en 9:16 avec fond flouté, y brûle des sous-titres Whisper et renvoie les clips.

    Deux contraintes ont dicté l'architecture : des fichiers lourds, d'où Pyrogram et le protocole MTProto pour envoyer jusqu'à deux gigaoctets, et un modèle payant, d'où des crédits achetés en Telegram Stars avec une file de traitement par utilisateur. Le même moteur existe en tableau de bord web, qui a servi de banc d'essai avant la version bot.

    Python, python-telegram-bot, Pyrogram, yt-dlp, faster-whisper, MoviePy

  3. LAB/032025-2026En cours

    G2TiktokAutopost, le publieur

    Publie des séries de vidéos sur plusieurs comptes TikTok, piloté depuis Telegram, en tenant compte des limites de la plateforme.

    L0 · Codetiktok_uploader/tiktok_bot/uploader_core.py
    if part == "\n":
        actions.reset_actions()
        actions.send_keys(Keys.SHIFT + Keys.ENTER).perform()
        time.sleep(0.1)
        continue
    if part.startswith("#"):
        tag_content = part[1:]
        if tag_content:
            actions.reset_actions()
            actions.send_keys("#").perform()
            time.sleep(0.5)
            actions.send_keys(tag_content).perform()
            time.sleep(2.5)  # Wait for dropdown
            actions.send_keys(Keys.ENTER).perform()  # Confirm
    L1 · Modules
    • tiktok_uploader/tiktok_bot/uploader_core.pyPilote Chrome : cookies, saisie, attente du bouton Publier
    • tiktok_uploader/tiktok_bot/bot_interface.pyMenus Telegram, séries, boucle d'upload en thread
    • tiktok_uploader/tiktok_bot/watcher.pyScanne les dossiers séries, trie par numéro
    • tiktok_uploader/tiktok_bot/main.pyPoint d'entrée, signale les nouvelles séries
    • tiktok_uploader/tiktok_bot/settings.pyConfig env, validation du dossier d'upload
    • tiktok_uploader/run.shPrépare le venv, empêche la mise en veille
    L2 · Services
    • Telegram Bot APIMenus, commandes, avancement
    • Telegram MTProto (Pyrogram)Téléchargement de secours des grosses vidéos
    • Selenium / undetected-chromedriverProfil Chrome persistant par compte
    • TikTok Creator CenterPage d'upload pilotée dans le navigateur
    1. L0CodeSaisie humaine de la légende, hashtags confirmés un à un
    2. L1Modules6 fichiers du dépôt
    3. L2Services4 services appelés

    Conception et développement, seul

    Le dernier maillon avant l'écran du spectateur. Les vidéos rendues sont rangées par séries, chaque série a son compte, et le bot publie à la cadence voulue en pilotant un navigateur avec Selenium sur des sessions enregistrées. Il contourne les fenêtres surgissantes, respecte les limites de débit et déplace chaque fichier publié dans un dossier posted/ pour ne jamais republier deux fois.

    Pas d'interface au-delà de Telegram : on y reçoit l'état des séries et les erreurs. C'est l'outil le plus fragile de la famille, parce qu'il dépend d'une interface qui n'est pas la sienne.

    Python, Selenium, Pyrogram, python-telegram-bot

  4. LAB/042026Prototype

    G2Tiktok-Live-inter, le jeu en direct

    Un jeu de devinettes pour TikTok Live : le chat propose, un overlay OBS affiche les scores et une voix annonce les manches.

    L0 · Surface
    Overlay OBS du jeu : question en cours, propositions du chat et tableau des scores.
    L1 · Codemodules/game_engine.py
    if user_msg == correct_answer:
        await self.handle_winner(user, avatar_url)
        return
    if len(user_msg) >= 3:
        ratio = SequenceMatcher(None, user_msg, correct_answer).ratio()
        if ratio >= 0.80:
            now = time.time()
            if now - self.last_near_miss.get(user, 0) < 5:
                return
            self.last_near_miss[user] = now
    L2 · Modules
    • modules/game_engine.pyManches, correspondance floue, délai des presque
    • modules/tiktok_client.pyCommentaires, cadeaux, follows vers le moteur
    • interfaces/overlay_server.pyServeur aiohttp et diffusion WebSocket JSON
    • modules/audio_generator.pyVoix Edge à la volée, cache purgé
    • overlay/app.jsOverlay navigateur : WebSocket, timer, popups
    • main.pyLance serveur, moteur, client et simulateur
    L3 · Services
    • TikTok Live (TikTokLive)Flux chat, likes, cadeaux, follows
    • EulerStreamSignature des requêtes Webcast
    • Microsoft Edge TTSVoix française des questions
    • OBS (source navigateur)Reçoit l'overlay par WebSocket
    1. L0SurfaceCapture réelle
    2. L1CodeRéponse exacte, réponse proche et délai par joueur
    3. L2Modules6 fichiers du dépôt
    4. L3Services4 services appelés

    Conception et développement, seul

    La famille G2 a un membre tourné vers le direct. Un client écoute le chat d'un TikTok Live, un moteur de jeu tient les questions, les réponses et les scores, un serveur WebSocket pousse l'état vers un overlay que le streamer incruste dans OBS, et une voix de synthèse annonce les manches.

    Prototype : les questions sont dans un fichier JSON, il n'y a pas de comptes ni de persistance au-delà d'une session. Il a servi à comprendre ce qu'un chat peut faire en temps réel, ce qui a nourri Roast My Music.

    Python, TikTokLive, WebSocket, edge-tts, OBS

  5. LAB/052025-2026En pause

    G2Trading-safe, le cousin hors vidéo

    Bot de trading asynchrone sur Solana : détection de nouveaux pools, analyse de sécurité automatique, exécution simulée ou réelle, pilotage Telegram.

    L0 · Codecore/sniper_analyzer.py
    has_mint_auth = mint_info.get("mint_authority") is not None
    has_freeze_auth = mint_info.get("freeze_authority") is not None
    if has_mint_auth:
        score -= 10  # Pénalité Mint Auth
        details["mint_revoked"] = False
        details["warnings"].append(
            "Mint Authority Active (Dev can create tokens)"
        )
    else:
        score += BONUS_MINT_REVOKED  # +15
        details["mint_revoked"] = True
    if has_freeze_auth:
        score -= 5  # Pénalité Freeze Auth
        details["freeze_revoked"] = False
    else:
        score += BONUS_FREEZE_REVOKED  # +10
        details["freeze_revoked"] = True
    L1 · Modules
    • core/scanner.pyÉcoute des logs Raydium, nouveaux pools
    • core/sniper_analyzer.pyScore : autorités, liquidité, achats/ventes, détenteurs
    • core/token_health_monitor.pySanté du token : volume, structure, temps, liquidité
    • core/trader.pyAchat, paliers de gain, stop, trailing, sortie temporelle
    • interface/telegram_bot.pyTableau de bord et alertes aiogram
    • database/db_manager.pyTrades et positions en SQLite
    L2 · Services
    • Solana RPCWebSocket des logs et transactions
    • RaydiumPools de liquidité surveillés
    • DexScreener APILiquidité, volume, prix
    • JupiterCotations et swaps
    • Telegram Bot APIPilotage et alertes
    1. L0CodeAutorités de mint et de gel : pénalité ou bonus au score
    2. L1Modules6 fichiers du dépôt
    3. L2Services5 services appelés

    Conception et développement, seul

    Même socle que le reste de la famille, tableau de bord Telegram compris, mais un tout autre terrain. Le bot écoute la blockchain Solana par WebSocket pour repérer les nouveaux pools de liquidité sur Raydium, passe chaque candidat au crible (pot de miel, autorités de mint et de gel, concentration des détenteurs), puis exécute, en simulation ou en réel, avec des règles de gestion après achat : sécurisation d'une partie des gains, liquidation des positions qui stagnent, stop et objectif dynamiques.

    Il est présenté ici pour la mécanique : temps réel, sécurité automatisée, asynchrone de bout en bout. Pas comme un conseil, et il est en pause.

    Python, asyncio, aiogram, Solana, WebSocket

Autres essais

Trois projets indépendants du socle Telegram : un format de live, une application de terrain, un prototype de santé comportementale.

  1. LAB/062025-2026Prototype

    Roast My Music

    Plateforme pour streamers : écouter des morceaux en live et les noter avec sa communauté, votes du chat Twitch et TikTok en temps réel.

    L0 · Surface
    Tableau de bord du streamer : lecture en cours, note du streamer, moyennes Twitch et TikTok, score final verrouillé et activité en direct.
    L1 · Codescripts/live-listener.mjs
    let multiplier = 1;
    if (coins > 0 && coins < 100) multiplier = 1.5;
    else if (coins >= 100 && coins < 500) multiplier = 2;
    else if (coins >= 500) multiplier = 3;
    
    // updateUserScore(platform, user, score)
    users.forEach(u => {
        const rawScore = db.currentSession.scores[platform][u];
        const weight = savedMultipliers[u] || 1; // Default 1
        totalWeightedScore += rawScore * weight;
        totalWeight += weight;
    });
    const avg = totalWeight > 0 ? totalWeightedScore / totalWeight : 0;
    db.currentSession.averages[platform] = parseFloat(avg.toFixed(1));
    L2 · Modules
    • scripts/live-listener.mjsPont Twitch et TikTok : votes, cadeaux, moyennes
    • src/app/api/session/route.jsNote du streamer, score global, clôture des votes
    • src/components/StreamerDashboard.jsLecture en cours, note, moyennes par plateforme
    • src/app/overlay/page.jsOverlay OBS du score global
    • src/app/history/page.jsSessions archivées
    • src/lib/db.jsSession et historique en JSON
    L3 · Services
    • Twitch IRC (tmi.js)Lecture des votes du chat Twitch
    • TikTok Live (tiktok-live-connector)Votes et cadeaux du live TikTok
    • Spotify Web APIMorceau en cours et contrôle
    • YouTube (lecteur)Lecture des morceaux
    1. L0SurfaceCapture réelle
    2. L1CodeUn cadeau TikTok multiplie le poids du vote
    3. L2Modules6 fichiers du dépôt
    4. L3Services4 services appelés

    Conception et développement, seul

    Le point de départ est un format de live : un streamer écoute des morceaux ou des albums avec sa communauté et les note en direct. Roast My Music outille ce moment. Le streamer charge un morceau, donne sa note de 1 à 10, et le chat vote en même temps : les messages Twitch et TikTok sont lus en temps réel, pondérés (un cadeau TikTok pèse plus qu'un message), et le score final se fige quand les votes sont clos.

    Trois surfaces : le tableau de bord du streamer (lecture en cours, sa note, les moyennes par plateforme, l'activité du chat en direct), un overlay à incruster dans le live qui affiche le score qui bouge, et un historique des sessions. Un pont écoute les chats via tmi.js pour Twitch et un connecteur TikTok Live.

    Une seconde piste, plus ancienne, explorait la fiche d'album classique avec notes et critiques. Elle a servi à tester le parcours de notation, mais c'est le format live qui porte le produit : la note collective en temps réel est ce que ni Letterboxd ni RateYourMusic ne font.

    État réel : prototype fonctionnel en local, pas de comptes, sessions stockées en JSON. Prochaine étape : un modèle de données partagé et l'authentification Twitch pour ouvrir l'outil à d'autres streamers.

    Next.js, TypeScript, Sass, tiktok-live-connector, tmi.js

  2. LAB/072024-2025En pause

    Hall of Arts

    Application mobile de découverte du street art parisien en réalité augmentée. Projet de diplôme mené à trois, sur une idée que j'ai portée.

    L0 · Codesrc/components/Map/MapComponent.js
    initialRegion={userLocation ? undefined : initialRegion}
    onRegionChangeComplete={region => {
      const calculatedZoom = Math.log2(360 / region.latitudeDelta) + 1;
      setZoom(calculatedZoom);
    }}>
    {userLocation && (
      <Marker
        coordinate={{
          latitude: userLocation.latitude,
          longitude: userLocation.longitude,
        }}
        anchor={{x: 0.5, y: 0.5}}>
    L1 · Modules
    • src/components/Navbar/Navbar.jsOnglets : fil, carte, ajout, réactions, profil
    • src/api/hooks/useWorkService.jsClient des œuvres : liste, détail, création, images
    • src/components/Map/MapComponent.jsCarte : suivi GPS, œuvres en marqueurs, zoom calculé
    • src/components/Map/CustomMarker.jsMarqueur image dont la taille suit le zoom
    • src/screens/AddArt/AddArt.jsFiche : photo, recherche Deezer, publication
    • src/screens/ViewArt/Œuvre : piste Deezer, lecture audio, photos
    L2 · Services
    • API REST maison (axios)Œuvres, images, création
    • Deezer APIRecherche et extraits de pistes
    • react-native-mapsCarte native et marqueurs
    • GéolocalisationPosition de l'utilisateur en continu
    1. L0CodeZoom déduit de la région affichée, marqueur ancré
    2. L1Modules6 fichiers du dépôt
    3. L2Services4 services appelés

    Chef de projet et développeur, équipe de trois, projet de diplôme ESIEE IT

    L'idée de départ était la mienne : la rue est un musée de street art à ciel ouvert, sans cartel ni guide. Hall of Arts géolocalise les œuvres autour de soi sur une carte, raconte chacune avec du texte et de l'audio, garde une frise de son évolution à partir des photos de la communauté, laisse les artistes revendiquer et publier leurs œuvres, et permet de voir une œuvre en réalité augmentée là où elle se trouve, même quand elle a été effacée.

    Nous étions trois. J'ai tenu le rôle de chef de projet, du cadrage aux jalons de rendu, et celui de développeur sur l'application mobile en React Native : carte et géolocalisation, fiches d'œuvres avec lecteur audio, notes et avis, remontée des photos. La première version reposait sur Firebase et Mapbox ; la reprise de 2026 passe sur une API dédiée et prépare la vue en réalité augmentée avec ViroReact. Le projet a été présenté comme projet de fin d'études et a compté pour l'obtention du diplôme.

    Une nouvelle version, avec un back-end refondu, a été entamée en 2026. Le projet est présenté ici pour ce qu'il est : un projet d'école abouti, en pause, dont la réalité augmentée sur des téléphones hétérogènes reste la leçon la plus coûteuse et la plus utile.

    React Native, Firebase, Mapbox, ViroReact (AR), TypeScript

    Code

  3. LAB/082025Prototype

    Make My Dry

    Prototype d'application de santé comportementale pour réduire progressivement une consommation, par paliers et suivi quotidien.

    L0 · Codesrc/components/home/DailyChart.tsx
    const DailyChart: React.FC<Props> = ({ entries }) => {
      const dataByHour = Array(24).fill(0);
      entries.forEach((entry) => {
        dataByHour[entry.hour]++;
      });
      const [tooltip, setTooltip] = useState<{ x: number; y: number } | null>(null);
      const [tooltipText, setTooltipText] = useState<string>('');
      const [fadeAnim] = useState(new Animated.Value(0));
      const handlePointClick = (data: any) => {
        const matchedEntry = entries.find((e) => e.hour === Math.floor(data.index));
        if (!matchedEntry) return;
    L1 · Modules
    • src/screens/Home/HomeScreen.tsxÉtat des relevés, relie modale et graphique
    • src/components/home/AddEntryModal.tsxChoix de la raison, horodatage à l'heure
    • src/components/home/DailyChart.tsxCompteur par heure, courbe et infobulle
    • src/components/home/WelcomeCard.tsxDate du jour et message selon le compte
    • src/type/Entry.tsxRelevé : heure, horodatage, raison
    L2 · Services
    • react-native-chart-kitCourbe des relevés par heure
    • React NavigationPile native à un écran
    • React NativeExécution iOS et Android
    1. L0CodeVingt-quatre cases horaires pour la courbe du jour
    2. L1Modules5 fichiers du dépôt
    3. L2Services3 services appelés

    Conception et développement, seul

    Un prototype mobile qui applique une méthode simple : sept jours d'observation pour établir une consommation de référence, puis un plan de réduction par paliers, avec un relevé quotidien et les raisons de chaque prise. Les graphiques montrent l'écart entre le plan et le réel.

    C'est une application de santé comportementale au même titre qu'un carnet de sommeil ou un suivi de sevrage tabagique. Elle prolonge, sur un autre terrain, le travail fait sur Neocortex : donner à une personne et à celui qui l'accompagne un outil de mesure honnête plutôt qu'un jugement.

    Le prototype n'a pas dépassé le stade de la démonstration locale : pas de compte, pas de synchronisation, pas de validation clinique.

    React Native, TypeScript, Reanimated, react-native-chart-kit