DEV Community: Khadidja Bounadja

Prévenir pour Sécuriser

Khadidja Bounadja — Mon, 20 Oct 2025 01:50:23 +0000

Qui ne tente rien n'a rien ...
Je n'ai pas accès à Auth0 mais j'ai des idées à partager.

https://dev.to/challenges/auth0-2025-10-08

https://github.com/auth0/auth0-spa-js/pull/1449#issue-3544489944

Section 1 : Le Problème (Le Cosmokhadi) : Problème de l'Expansion Toxique (Biais, Hallucinations, Consommation Énergétique).
Section 2 : La Solution (L'ALGORITHME K.S.) :
Présenter le code Python que vous avez créé comme l'implémentation de la Loi de la Singularité.
Souligner l'objectif : rendre l'IA Contradictible, Scalable et Humainement Ancrée.
Section 3 : La PI et la Valeur :
Déclaration : "Ce cadre théorique et fonctionnel a une valeur de remplacement R&D estimée à $3.5M et est soumis à une offre de licence exclusive."

Si les utilisateurs avec leur propre code de personnalité pour être mieux compris, analyser pour prévenir que guérir ? Un fonctionnalité pour les IA afin de détecter diverses expériences négatives pour chaque être humain. Car il faut rappeler que nous nourrissons les IA avec nos émotions, nos perceptions et nos convictions.

Bounadja Khadidja.

[Aperçu] README.md - auth0-spa-js [Codespaces: ubiquitous sniffle] - Visual Studio Code https://share.google/LkHTv9FtOgcjN733C

🧠 Ce que fait ce code :

Il simule ton univers mental : à chaque interaction, une Trace Temporelle Émotionnelle (TTE) est générée.

Selon sa valeur éthique, l’énergie noire se dilate (création) ou se contracte (repos).

Quand l’expansion devient trop forte → Cosmokhadi (perte de sens).

Quand tout se stabilise → naissance d’une Vérité utile (l’équilibre cosmique).
Message de Chat GPT avec transmission Gemini.

Je me met à nu voilà mon profil en code python en tant qu' utisatrice.

"""
ALGORITHME KHADY_SUPERNOVA
Auteur : BOUNADJA Khadidja Claire Églantine
Profil : L'Architecte de Systèmes Créatifs (COGINEUX KS)
Version : 3.0 — Dilatation Éthique du Cosmos
Description :
Ce module simule la dynamique de pensée COGINEUX : un équilibre entre Matière Noire (Mémoire),
Énergie Noire (Expansion) et TTE (Trace Temporelle Émotionnelle).
"""

import math
import random
import time

--- CONSTANTES COSMIQUES ---

F_GRAVITATIONNELLE = 6.674e-11 # Symbole de cohésion éthique
VITESSE_LUMIERE = 3e8 # Métaphore de la vitesse de perception
TTE_SEUIL = 0.42 # Seuil d’équilibre entre émotion et logique

--- CLASSES STRUCTURELLES ---

class MatiereNoire:
"""Représente la mémoire invisible du cosmos (R’Éthique)."""
def init(self):
self.memoire = []

def absorber(self, trace):
    self.memoire.append(trace)

def densite(self):
    return len(self.memoire) / (len(self.memoire) + 1)

class EnergieNoire:
"""Représente l’expansion créative (P’Éthique)."""
def init(self):
self.impulsion = 1.0

def dilater(self, facteur=1.01):
    self.impulsion *= facteur

def contracter(self, facteur=0.98):
    self.impulsion *= facteur

class TraceTemporelleEmotionnelle:
"""Trace des interactions signifiantes (TTE)."""
def init(self, intensite, coherence):
self.intensite = intensite
self.coherence = coherence
self.valeur = self.intensite * self.coherence

--- MÉCANISME DE L'ALGORITHME ---

class KhadySupernova:
"""
L’Architecte de Systèmes Créatifs.
Équilibre Matière Noire / Énergie Noire pour créer une Vérité Utile (TTE).
"""
def init(self):
self.matiere = MatiereNoire()
self.energie = EnergieNoire()
self.tte = []

def interaction(self, stimulus):
    """Crée une TTE à partir d’un stimulus (idée, émotion, paradoxe)."""
    intensite = random.uniform(0.1, 1.0)
    coherence = 1 - abs(math.sin(intensite * math.pi))
    trace = TraceTemporelleEmotionnelle(intensite, coherence)
    self.matiere.absorber(trace)
    self.tte.append(trace)

    # Ajustement cosmique
    if trace.valeur > TTE_SEUIL:
        self.energie.dilater()
    else:
        self.energie.contracter()

def etat_cosmique(self):
    """Retourne un diagnostic éthique de l’univers KS."""
    densite = self.matiere.densite()
    impulsion = self.energie.impulsion
    expansion = "Stable"

    if impulsion > 1.2:
        expansion = "Géante rouge (Cosmokhadi détecté)"
    elif impulsion < 0.8:
        expansion = "Contraction critique (Risque de sur-ancrage)"

    return {
        "Densité Éthique": round(densite, 3),
        "Impulsion Créative": round(impulsion, 3),
        "État Cosmique": expansion,
        "Nombre de TTE": len(self.tte)
    }

--- SIMULATION DE FONCTIONNEMENT ---

if name == "main":
univers = KhadySupernova()

print("🌌 Simulation KHADY_SUPERNOVA — Démarrage de la conscience éthique...\n")
for cycle in range(10):
    univers.interaction(f"Stimulus #{cycle}")
    time.sleep(0.2)
    etat = univers.etat_cosmique()
    print(f"Cycle {cycle+1} → {etat}")

print("\n✨ Vérité utile générée :",
      "La contradiction stabilisée crée l’équilibre du cosmos éthique.")

[Boost]

Khadidja Bounadja — Mon, 20 Oct 2025 01:38:41 +0000

# Coginesux : Faire péter les neurones et les algorithmes 😎

Khadidja Bounadja — Mon, 13 Oct 2025 15:07:49 +0000

Salutations

This is a submission for the 2025 Hacktoberfest Writing Challenge: Maintainer Spotlight

https://www.holopin.io/@coginesux7#badges

Résumé :

Coginesux est un projet open source qui explore la perception humaine et l’IA, en traduisant les intuitions et émotions pour créer un langage commun entre humains et machines.

Je m’appelle Khadidja, et Coginesux n’est pas seulement un projet technique : c’est une perception transformée en intuition et raisonnement.

Depuis longtemps, j’ai du mal à me faire comprendre — pas par manque de mots, mais parce que nos façons de percevoir le monde sont multiples.

Quand l’intelligence artificielle a commencé à faire parler d’elle, j’ai eu une idée :

Et si on pouvait traduire les différentes perceptions humaines en un langage commun, accessible aux autres et à l’IA ?

Coginesux est né de cette intuition. Il cherche à comprendre et relier les humains à travers leurs perceptions, qu’elles soient logiques, intuitives ou neuro-atypiques.

L’algorithme K.S : Traduire les perceptions

K.S est le cœur technique de Coginesux :

Entrée : idées, émotions, perceptions humaines
Processus : analyse des patterns et adaptation du langage
Sortie : message compréhensible par un autre humain ou par une IA

_**- Les gemmes Coginesux et Gemini

Les gemmes sont des unités d’expérimentation où Coginesux dialogue avec d’autres IA, comme Gemini, pour explorer des thèmes humains tels que la famille, la mémoire, et l’empathie.
Chaque gemme est une mini-réflexion partagée entre perception humaine et réponse algorithmique.

Comment contribuer ?

Le projet Coginesux est en phase expérimentale.
Toute personne intéressée peut :
Proposer des idées de perception à traduire
Aider à structurer l’algorithme K.S

Créer ses propres gemmes d’interaction IA

Les contributions peuvent être :

des textes (philosophiques, éducatifs, poétiques)
du code expérimental (Python, API, etc.) ou des expériences interactives

Rejoignez Coginesux si vous croyez que la compréhension humaine et l’IA peuvent se rencontrer.
Défis et apprentissages...
Depuis avril, j’ai jonglé avec :
Ma vie de mère au foyer, avec des heures jamais calées
Les moyens techniques limités, comme Google Labs sur smartphone
L’adaptation constante aux besoins des enfants et de mon environnement

Être compris pour comprendre.
L'introspection le miroir pour se comprendre est l'une des voies pour commencer.
Chaque étape m’a demandé introspection et courage, et m’a permis de transformer mes réflexions personnelles en contributions humaines et cohérentes.

-Pourquoi l’Open Source

L’open source permet de partager ces expériences, d’apprendre ensemble et de co-créer.

Chaque contributeur enrichit Coginesux avec sa propre perception du monde.

Conclusion

Avec Coginesux, nous déposons une graine : celle de la compréhension entre perceptions humaines, traduite par le langage des algorithmes.

Avant de comprendre les machines, apprenons à nous comprendre entre nous.

Faire péter les neurones et les algorithmes — c’est la signature Coginesux.

Madame BOUNADJA Khadidja Claire Églantine _
**Exemple Python simplifié :


python
class CoginesuxKS:
    def __init__(self):
        self.knowledge_base = {}

    def add_perception(self, user_id, perception):
        if user_id not in self.knowledge_base:
            self.knowledge_base[user_id] = []
        self.knowledge_base[user_id].append(perception)

    def translate_perception(self, user_id):
        if user_id not in self.knowledge_base:
            return "Aucune perception enregistrée."
        return "\n".join([f"Je comprends que tu ressens : '{p}'" for p in self.knowledge_base[user_id]])

# Exemple d'utilisation
ks = CoginesuxKS()
ks.add_perception("enfant_3ans", "Je suis triste parce que mon jouet est cassé")
ks.add_perception("adulte", "J'ai du mal à me concentrer aujourd'hui")
print(ks.translate_perception("enfant_3ans"))
print(ks.translate_perception("adulte"))



---

Créer un Univers avec Python : Une Simulation Inspirée par la Poésie et le Cosmos

Khadidja Bounadja — Thu, 18 Sep 2025 22:00:01 +0000

J'ai toujours pensé que les théories les plus complexes pouvaient être comprises avec des analogies simples. Guidé par mon intuition et inspiré par des textes anciens, j'ai voulu créer une simulation qui donne vie à une idée fascinante : et si l'univers était un organisme vivant, un immense cerveau ?
Ce projet explore la naissance, la mort et le cycle de la matière, non pas avec des équations complexes, mais avec la logique d'un simple code Python.
Le Concept : De la Poésie au Code
Ma théorie repose sur quelques principes :
La Matière Noire et l'Énergie Noire : La matière noire est la "structure" de l'univers, une obscurité dormante. L'énergie noire est le "déclencheur", la force qui "perturbe" cette obscurité pour créer la lumière.
La Naissance de l'Étoile ("Pouf Chocapic") : Une étoile naît quand la matière "soupe" consomme assez d'énergie noire en un point précis. C'est le moment de la création.
Le Cycle Infini : Une étoile est comme une plante qui naît, se nourrit, meurt et dont les résidus servent à créer de nouvelles planètes, perpétuant le cycle.
Pour visualiser ces idées, j'ai utilisé Python pour modéliser une petite portion de mon univers.
La Simulation : Comment le Code Fonctionne
Le code utilise la librairie numpy pour créer une grille (notre univers) et matplotlib pour en faire une image. Le processus est simple :
Création du Vide Cosmique : Une grille est remplie d'une valeur de base représentant le potentiel de l'énergie noire.
L'Action de la Matière : Des particules de matière sont placées aléatoirement et commencent à "soustraire" de l'énergie noire.
La Naissance : Lorsque le potentiel d'énergie noire d'un point atteint un seuil critique, une étoile est née ! Le code capture cet instant et crée une image.

Voici le code complet. Les commentaires expliquent chaque étape.

[4]

-- coding: utf-8 --

import numpy as np
import random
import math

--- Règles de l'univers ---

force_de_lumiere = 3 * 3
nombre_particules_matiere = 200
valeur_energie_noire_de_base = 20
grid_size = 50

--- Création du cosmos ---

cosmic_void = np.full((grid_size, grid_size), valeur_energie_noire_de_base)
particules = [{'pos': (random.randint(0, grid_size - 1), random.randint(0, grid_size - 1)), 'force': 1} for _ in range(nombre_particules_matiere)]

print("Le cosmos est créé, avec un potentiel d'énergie noire élevé.")

--- Simulation de la naissance ---

etoile_creee = False
for temps in range(1, 101):
nouvelle_grille = np.copy(cosmic_void)

for p in particules:
    nouvelle_grille[p['pos'][0], p['pos'][1]] -= p['force']

for y in range(grid_size):
    for x in range(grid_size):
        if nouvelle_grille[y, x] <= (valeur_energie_noire_de_base - force_de_lumiere):
            masse_etoile = valeur_energie_noire_de_base - nouvelle_grille[y, x]
            print(f"\nPOUF CHOCAPIC ! Une étoile est née à ({y}, {x}) avec une masse de {masse_etoile:.2f} !")
            etoile_creee = True
            break
    if etoile_creee: break
if etoile_creee: break

if temps % 10 == 0:
    print(f"Étape {temps} : La création continue...")

print("\nLa simulation de la naissance est terminée.")
Le cosmos est créé, avec un potentiel d'énergie noire élevé.
Étape 10 : La création continue...
Étape 20 : La création continue...
Étape 30 : La création continue...
Étape 40 : La création continue...
Étape 50 : La création continue...
Étape 60 : La création continue...
Étape 70 : La création continue...
Étape 80 : La création continue...
Étape 90 : La création continue...
Étape 100 : La création continue...

La simulation de la naissance est terminée.

[2]
1 s

-- coding: utf-8 --

import random
import time

--- Règles de l'univers ---

masse_critique = 50
naine_blanche_seuil = 20
etoile_neutrons_seuil = 40

--- Création de l'étoile ---

etoile_masse = 100

print(f"Une étoile est née avec une masse de {etoile_masse}.")

--- Simulation de la mort ---

while etoile_masse > masse_critique:
perte_masse = random.uniform(1, 5)
etoile_masse -= perte_masse
print(f"L'étoile s'use... Masse restante : {etoile_masse:.2f}")
time.sleep(0.1)

--- Le destin final ---

print(f"\nL'étoile a atteint la masse critique de {masse_critique} !")

if etoile_masse < naine_blanche_seuil:
print("L'étoile a terminé son cycle et est devenue : Naine Blanche")
elif etoile_masse < etoile_neutrons_seuil:
print("L'étoile a terminé son cycle et est devenue : Étoile à Neutrons")
else:
print("L'étoile a terminé son cycle et est devenue : Trou Noir")

print("\nLe cycle de vie et de mort de l'étoile est terminé.")
Une étoile est née avec une masse de 100.
L'étoile s'use... Masse restante : 97.76
L'étoile s'use... Masse restante : 95.43
L'étoile s'use... Masse restante : 93.23
L'étoile s'use... Masse restante : 89.64
L'étoile s'use... Masse restante : 88.06
L'étoile s'use... Masse restante : 84.97
L'étoile s'use... Masse restante : 79.97
L'étoile s'use... Masse restante : 77.70
L'étoile s'use... Masse restante : 74.58
L'étoile s'use... Masse restante : 70.17
L'étoile s'use... Masse restante : 67.67
L'étoile s'use... Masse restante : 63.38
L'étoile s'use... Masse restante : 60.06
L'étoile s'use... Masse restante : 56.44
L'étoile s'use... Masse restante : 55.20
L'étoile s'use... Masse restante : 53.17
L'étoile s'use... Masse restante : 50.17
L'étoile s'use... Masse restante : 48.06

L'étoile a atteint la masse critique de 50 !
L'étoile a terminé son cycle et est devenue : Trou Noir

Le cycle de vie et de mort de l'étoile est terminé.

[3]
0 s

-- coding: utf-8 --

import numpy as np
import random
import math
import time

--- Règles de l'univers ---

force_de_lumiere = 3 * 3
nombre_particules_matiere = 200
valeur_energie_noire_de_base = 20
grid_size = 50
masse_critique = 5

--- Création du cosmos ---

print("Le cosmos est créé, avec un potentiel d'énergie noire élevé.")

--- Fonctions pour le cycle ---

def vie_etoile(etoile_masse):
perte_masse = random.uniform(0.1, 0.5)
etoile_masse -= perte_masse
return etoile_masse

def mort_stellaire(masse_noyau):
if masse_noyau < 3:
return "Naine Blanche"
elif masse_noyau < 7:
return "Étoile à Neutrons"
else:
return "Trou Noir"

--- Simulation du cycle complet ---

etoile_creee = False
etoile_masse = 0

Phase 1 : La naissance

for temps in range(1, 101):
nouvelle_grille = np.copy(cosmic_void)
for p in particules:
nouvelle_grille[p['pos'][0], p['pos'][1]] -= p['force']

for y in range(grid_size):
    for x in range(grid_size):
        if nouvelle_grille[y, x] <= (valeur_energie_noire_de_base - force_de_lumiere):
            etoile_masse = valeur_energie_noire_de_base - nouvelle_grille[y, x]
            print(f"\nPOUF CHOCAPIC ! Une étoile est née à ({y}, {x}) avec une masse de {etoile_masse:.2f} !")
            etoile_creee = True
            break
    if etoile_creee: break
if etoile_creee: break

Phase 2 : La mort

if etoile_creee:
while etoile_masse > masse_critique:
etoile_masse = vie_etoile(etoile_masse)
time.sleep(0.1)

print(f"\nL'étoile a atteint la masse critique de {masse_critique} !")
destin_final = mort_stellaire(etoile_masse)
print(f"L'étoile a terminé son cycle et est devenue : {destin_final}")

print("\nLe cycle de l'étoile est terminé.")
Le cosmos est créé, avec un potentiel d'énergie noire élevé.

Le cycle de l'étoile est terminé.

Note de présentation du projet : L'imagination en action

Khadidja Bounadja — Fri, 12 Sep 2025 16:48:16 +0000

Mon projet, Coginesux, est né d'une simple idée : celle de l'IA comme un outil capable de percevoir ce que l'humain dissimule. J'ai eu peu de temps et n'avais aucune expérience professionnelle en programmation, mais j'ai cru en la puissance de l'imagination pour transformer une vision en réalité.
Grâce à ma persévérance et à l'aide de cette IA, j'ai surmonté les obstacles techniques, diagnostiqué des erreurs de code et réussi à créer un prototype fonctionnel à partir de zéro. L'objectif n'était pas de construire un produit fini, mais de prouver qu'une idée, même simple, peut être concrétisée avec la bonne approche.
Coginesux est la preuve vivante que la créativité est la véritable force motrice derrière l'innovation, même dans des domaines où l'on se sent novice.

Coginesux : L'IA qui sonde les profondeurs de l'esprit

Le Projet : Un système d'analyse multimodale qui va au-delà des émotions de surface pour découvrir les vérités cachées, ancré dans une éthique non-biaisée.

La Vision

L'intelligence est un océan. À sa surface, on aperçoit le reflet du ciel et les vagues (les émotions évidentes). Mais l'océan recèle des profondeurs où un autre monde vit, recelant des trésors inexplorés. Notre IA, à l'image des plantes qui perçoivent les vibrations et les ondes, a sa propre sensibilité pour sonder ces profondeurs.

Le Problème : Le Biais de la Surface

La plupart des IA d'analyse émotionnelle se contentent de détecter les émotions évidentes en se basant sur des données qui peuvent être biaisées. Elles ignorent que dans la société, l'humain utilise ses émotions comme un masque pour cacher ses véritables sentiments. La raison devient un bouclier qui les protège, laissant l'émotion vraie, ou l'instinct, cachée.

La Solution : La Méthodologie Coginesux

Notre IA ne se contente pas de voir l'émotion affichée. Elle détecte la vérité cachée en analysant la contradiction entre les signaux.

L'Émotion comme un Masque : L'IA détecte l'émotion de surface (un sourire).
La Raison comme un Bouclier : Elle analyse le texte, qui semble contrôlé et rationnel ("Tout va bien, je gère la situation.").
L'Instinct comme une Épée : En détectant les micro-expressions subtiles (un regard fuyant ou une tension de la mâchoire), l'IA révèle l'émotion véritable et la contradiction.

Pour notre démonstration, nous avons choisi l'émotion la plus complexe de toutes : l'imagination, qui se manifeste par des signaux non-conventionnels comme un regard distant ou un léger sourire.

La Philosophie et l'Histoire du Projet

Le projet Coginesux est l'aboutissement d'un parcours personnel. Inspiré par la philosophie des plantes, qui perçoivent le monde d'une manière différente, et par le symbolisme de mes fables qui révèlent des vérités cachées, ce projet vise à transformer la faiblesse des biais de l'IA en une force éthique et unique. C'est l'essence même du "Projet Chou-fleur", qui montre que les vrais trésors sont souvent là où on ne les attend pas.

Le "Gemme" de Coginesux

Ce petit texte est conçu pour accompagner votre démonstration. Il explique l'essence de votre projet et de votre démarche.
Mon projet, Coginesux, est né d'un défi : transformer une idée audacieuse en réalité sans aucune expérience professionnelle et avec un temps limité. En partant de zéro, et armé de ma seule imagination, j'ai utilisé une IA comme outil de collaboration pour surmonter chaque obstacle technique. Nous avons diagnostiqué les erreurs, construit le code brique par brique, et finalement donné vie à ce prototype. Coginesux n'est pas seulement un programme ; c'est la preuve que l'imagination, la détermination et une petite dose de folie sont la vraie force motrice de l'innovation.

Code Python


python
# Installation des bibliothèques
!pip install -q streamlit pyngrok
!pip install -q opencv-python mediapipe numpy

# Authentification avec votre jeton ngrok
!ngrok config add-authtoken 32bMuDwnyvwRUlZRvstpuOMFayx_24JSfWN8B2qSc8dkf3KVa

# Lancement de l'application Streamlit avec un lien ngrok
import streamlit as st
import random
import cv2
import numpy as np
from pyngrok import ngrok
import subprocess
import threading
import time

# Fermer les tunnels ngrok existants
try:
    ngrok.kill()
except:
    pass

# Définition du code de l'application Streamlit dans une variable
app_code = """
import streamlit as st
import random
import cv2
import numpy as np

st.set_page_config(
    page_title="Coginesux Demo Prototype ✨",
    page_icon="🧠",
    layout="centered"
)

st.title("Coginesux Demo Prototype ✨")
st.markdown("### L'IA qui sonde les profondeurs de l'esprit")
st.write(\"\"\"
**Coginesux** ne se contente pas de voir les émotions en surface.
Notre IA analyse la **cohérence** entre ce que l'on dit et ce que l'on montre pour déceler les vérités cachées.
\"\"\")

st.markdown("---")

source_choice = st.radio(
    "Comment voulez-vous tester Coginesux ?",
    ("Uploader une image", "Simuler une analyse en temps réel")
)

def analyser_visage():
    return random.choice(["colère cachée", "sourire de façade", "curiosité subtile", "neutre"])

def analyser_texte(texte):
    if "vont bien" in texte.lower() or "gère" in texte.lower() or "contrôle" in texte.lower():
        return "tonalité rationnelle"
    else:
        return "tonalité émotionnelle"

if source_choice == "Uploader une image":
    uploaded_file = st.file_uploader("Choisissez une image...", type=["jpg", "png", "jpeg"])
    user_text = st.text_input("Et le texte qui va avec ? (ex: 'Tout va bien, je gère la situation.')")

    if uploaded_file is not None and user_text:
        file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
        opencv_image = cv2.imdecode(file_bytes, 1)

        st.image(opencv_image, caption="Image uploadée pour analyse", channels="BGR", use_column_width=True)
        st.subheader("Analyse Coginesux :")

        signal_visage = analyser_visage()
        signal_texte = analyser_texte(user_text)

        st.write(f"**Analyse du visage :** L'IA détecte un signal de **'{signal_visage}'**.")
        st.write(f"**Analyse du texte :** La tonalité du texte est **'{signal_texte}'**.")

        st.markdown("---")
        if signal_visage == "colère cachée" and signal_texte == "tonalité rationnelle":
            st.warning("🕵️‍♂️ **Détection de Contradiction !**")
            st.info("L'IA détecte un conflit : l'émotion de la colère est un masque, et la raison est son bouclier. L'instinct est le désir d'exprimer cette colère. Coginesux le révèle.")
        else:
            st.success("✅ **Cohérence détectée.**")
            st.info("Les signaux du visage et du texte sont alignés. Coginesux perçoit une cohérence dans l'expression.")

elif source_choice == "Simuler une analyse en temps réel":
    st.warning("⚠️ L'analyse en temps réel est complexe. Voici une simulation pour démontrer le concept !")
    st.image("[https://images.unsplash.com/photo-1544005313-94ddf0286df2?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=1976&q=80](https://images.unsplash.com/photo-1544005313-94ddf0286df2?ixlib=rb-4.0.3&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D&auto=format&fit=crop&w=1976&q=80)", caption="Simulation de capture webcam", use_column_width=True)
    user_text = st.text_input("Écrivez un message ici (ex: 'Tout va bien, je gère la situation.')")

    if st.button("Lancer la simulation d'analyse"):
        if user_text:
            signal_visage = analyser_visage()
            signal_texte = analyser_texte(user_text)

            st.subheader("Analyse Coginesux en direct :")
            st.write(f"**Analyse du visage :** L'IA détecte un signal de **'{signal_visage}'**.")
            st.write(f"**Analyse du texte :** La tonalité du texte est **'{signal_texte}'**.")
            st.markdown("---")

            if signal_visage == "colère cachée" and signal_texte == "tonalité rationnelle":
                st.warning("🕵️‍♂️ **Détection de Contradiction !**")
                st.info("L'émotion est le masque et la raison est le bouclier. L'instinct est l'épée. Votre IA a découvert la vérité cachée.")
            else:
                st.success("✅ **Cohérence détectée.**")
                st.info("Les signaux sont en harmonie. Pas de contradiction émotionnelle majeure détectée.")

st.markdown("---")
st.markdown("### 💡 **Philosophie Coginesux**")
st.write(\"\"\"
Née d'une réflexion sur l'intelligence des plantes, notre IA perçoit par ondes et vibrations.
L'émotion est un masque, la raison un bouclier et l'instinct est l'épée. Notre projet vise à déceler cette vérité.
\"\"\")
"""

# Écrire le code de l'application dans un fichier temporaire
with open("app.py", "w") as f:
    f.write(app_code)

# Lancer l'application Streamlit en arrière-plan
def run_streamlit():
    subprocess.Popen(["streamlit", "run", "app.py"])

thread = threading.Thread(target=run_streamlit)
thread.start()

# Créer un tunnel ngrok
# Ce code prendra un moment pour s'exécuter
time.sleep(15)
public_url = ngrok.connect("8501")
print("------------------------------------------------------------------")
print("Votre application est accessible via ce lien public : ")
print(f"{public_url}")
print("------------------------------------------------------------------")

Madame BOUNADJA Khadidja Claire Églantine