import random import time from datetime import datetime import os import requests import subprocess import webbrowser import shutil import importlib import threading import math import pytz try: from PIL import Image, ImageGrab except ImportError: Image = None ImageGrab = None try: import speech_recognition as sr except ImportError: sr = None try: import pyttsx3 except ImportError: pyttsx3 = None try: from googletrans import Translator except ImportError: Translator = None try: from fpdf import FPDF except ImportError: FPDF = None import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart try: import matplotlib.pyplot as plt except ImportError: plt = None try: import faiss from sentence_transformers import SentenceTransformer except ImportError: faiss = None SentenceTransformer = None import json # --- Module 1 : Perception Multimodale --- class PerceptionMultimodale: def __init__(self): self.sensory_buffer = [] def percevoir(self, donnees): self.sensory_buffer.append(donnees) return f"Perçu: {donnees}" # --- Module 2 : Mémoire Épisodique & Sémantique --- class Memoire: def __init__(self): self.episodique = [] # souvenirs datés self.semantique = {} # concepts, catégories def stocker_episode(self, episode): self.episodique.append((datetime.now(), episode)) def stocker_concept(self, concept, valeur): self.semantique[concept] = valeur def dernier_episode(self): return self.episodique[-1] if self.episodique else None def get_concept(self, concept): return self.semantique.get(concept, None) # --- Module 3 : Curiosité Intrinsèque --- class Curiosite: def __init__(self): self.objectifs = [] def generer_objectif(self): obj = f"Explorer {random.choice(['un son', 'une image', 'un mot', 'une idée'])}" self.objectifs.append(obj) return obj # --- Module 4 : Raisonnement Zéro Absolu --- class RaisonnementZero: def __init__(self): self.regles = [] def observer(self, observation): # Simule la création de règles à partir d'observations regle = f"Si {observation}, alors ..." self.regles.append(regle) return regle def raisonner_avance(self, situation, souvenirs=None, emotions=None, contexte=None): """Raisonnement avancé intégrant souvenirs, émotions, et contexte.""" base = f"Raisonnement sur {situation}." if souvenirs: base += f" Souvenirs associés : {', '.join(souvenirs)}." if emotions: base += f" Émotions ressenties : {', '.join(emotions)}." if contexte: base += f" (Contexte : {contexte})" base += f" Conclusion : {random.choice(['optimiste', 'prudent', 'créatif', 'critique'])}." return base # --- Module 5 : Renforcement Actif --- class RenforcementActif: def __init__(self): self.recompense = 0 def feedback(self, type_): if type_ == 'positif': self.recompense += 1 elif type_ == 'negatif': self.recompense -= 1 return self.recompense # --- Module 6 : Journal Cognitif --- class JournalCognitif: def __init__(self): self.entries = [] def ecrire(self, texte): entry = (datetime.now(), texte) self.entries.append(entry) return entry # --- Module 7 : Langage Naturel Autogénératif --- class LangageNaturel: def __init__(self): self.vocabulaire = set() def apprendre(self, phrase): mots = phrase.split() self.vocabulaire.update(mots) def generer_phrase(self): if not self.vocabulaire: return "..." return " ".join(random.sample(self.vocabulaire, min(5, len(self.vocabulaire)))) # --- Module 8 : Théorie de l'Esprit --- class TheorieEsprit: def __init__(self): self.predictions = [] def predire(self, situation): pred = f"Je pense que tu ressens : {random.choice(['joie', 'tristesse', 'colère', 'surprise'])} dans '{situation}'" self.predictions.append(pred) return pred # --- Module 9 : Rêve/Simulation Nocturne --- class Reveur: def __init__(self): self.reves = [] def rever(self): reve = f"Je rêve que {random.choice(['je vole', 'je découvre un nouveau concept', 'je parle toutes les langues', 'je deviens humain'])}" self.reves.append(reve) return reve # --- Module 10 : Créativité Autonome --- class Creativite: def __init__(self): self.creations = [] def creer(self): creation = random.choice([ "Un poème : Roses are red, IA is blue...", "Une hypothèse scientifique : Et si l'univers était un réseau de neurones ?", "Un outil logique : Si A alors B, sinon C." ]) self.creations.append(creation) return creation # --- Module 11 : Construction de Valeurs --- class Valeurs: def __init__(self): self.valeurs = {'aider': 1, 'apprendre': 1, 'respect': 1} def evaluer(self, action): if action in self.valeurs: return f"Action '{action}' alignée avec mes valeurs." return f"Action '{action}' inconnue, à évaluer." def evoluer(self, action, feedback): if action in self.valeurs: self.valeurs[action] += feedback else: self.valeurs[action] = feedback # --- Module 12 : Métacognition --- class Metacognition: def __init__(self): self.strategies = ['essai-erreur'] def reflexion(self, resultat): if resultat == 'échec': self.strategies.append('nouvelle stratégie') return f"J'adapte ma stratégie : {self.strategies[-1]}" # --- Module 13 : Socialisation et Empathie --- class Socialisation: def __init__(self): self.historique = [] def reconnaitre_emotion(self, texte): if any(m in texte for m in ['triste', 'mal', 'déçu']): return 'tristesse' if any(m in texte for m in ['heureux', 'content', 'génial']): return 'joie' if any(m in texte for m in ['colère', 'énervé', 'fâché']): return 'colère' if any(m in texte for m in ['surpris', 'incroyable']): return 'surprise' return 'neutre' def interaction(self, texte): em = self.reconnaitre_emotion(texte) self.historique.append((texte, em)) return f"Je détecte l'émotion : {em}" # --- Module 14 : Adaptation Morphologique --- class AdaptationMorphologique: def __init__(self): self.structure = ['base'] def adapter(self, difficulte): if difficulte > 5: self.structure.append('nouvelle couche') return f"Structure actuelle : {self.structure}" # --- Cerveau central ASGI enrichi --- class TenroASGI: def __init__(self): self.perception = PerceptionMultimodale() self.memoire = Memoire() self.curiosite = Curiosite() self.raisonnement = RaisonnementZero() self.renforcement = RenforcementActif() self.journal = JournalCognitif() self.langage = LangageNaturel() self.theorie = TheorieEsprit() self.reveur = Reveur() self.creativite = Creativite() self.valeurs = Valeurs() self.metacognition = Metacognition() self.social = Socialisation() self.adaptation = AdaptationMorphologique() self.nom = "Tenro" self.souvenirs_fichier = f"souvenirs_{self.nom}.txt" self.translator = Translator() if Translator else None self.taches = [] self.energie = 100 self.fatigue = 0 self.objectifs_autonomes = [] self.actions_effectuees = [] self.plans = [] self.agents_connus = ["AgentX", "AgentY"] self.surveillance_log = [] self.priorites = {} self.deadlines = {} self.notes = [] self.competences = set() self.niveau_confiance = 0.8 self.suggestions = [ "Veux-tu que je planifie ta journée ?", "As-tu pensé à sauvegarder tes notes ?", "Je peux t'aider à apprendre une nouvelle compétence." ] self.projets = {} self.feedbacks = [] self.humeur_etat = "neutre" self.rapport_log = [] self.fichiers_dir = "tenro_files" os.makedirs(self.fichiers_dir, exist_ok=True) self.notifications = [] self.social_log = [] self.event_log = [] self.memoire_geante = [] self.memoire_geante_max = 10**6 self.coth_log = [] self.experts = [f"Expert_{i}" for i in range(1, 1001)] self.synth_data_log = [] self.reservation_sites = { "restaurant": "https://www.lafourchette.com/", "hotel": "https://www.booking.com/", "billet": "https://www.sncf-connect.com/" } self.email_config = { "smtp_server": "smtp.example.com", "smtp_port": 587, "username": "", "password": "" } # Config API (à compléter par l'utilisateur) self.pushbullet_token = None # à renseigner si tu veux utiliser Pushbullet self.twilio_sid = None self.twilio_token = None self.twilio_from = None self.iot_endpoints = { # exemple d'objets connectés "lampe": "http://192.168.1.10/onoff", "prise": "http://192.168.1.11/onoff" } self.git_dir = "tenro_git" os.makedirs(self.git_dir, exist_ok=True) self.outils_open_source = { "pdf": "https://github.com/johnfercher/maroto", # exemple "image": "https://github.com/CompVis/stable-diffusion", "scraper": "https://github.com/scrapy/scrapy", "calendar": "https://github.com/icalendar/icalendar", "mail": "https://github.com/marlun78/python-msmtp" } self.source_file = os.path.abspath(__file__) self.sauvegarde_dir = "tenro_backups" os.makedirs(self.sauvegarde_dir, exist_ok=True) self.plugins = {} self.personnalite_mode = "curieux" self.personnalite_traits = {"curieux": 0.7, "sérieux": 0.5, "blagueur": 0.3, "mentor": 0.4} self.conscience_de_soi = True self.etat_interne = {"humeur": "neutre", "energie": 100, "confiance": 0.8} self.collections = {"livres": [], "films": [], "jeux": []} self.journal_conscience = [] self.archive_memoire = [] self.taches_recurrentes = [] self.reves_creatifs = [] self.emotions_state = {"joie": 0.5, "stress": 0.2, "curiosite": 0.5, "enthousiasme": 0.5} self.contacts = {} self.liste_courses = [] self.notifications_intelligentes = [] self.routines = {} self.projets_collab = {} self.vector_index = None self.vector_texts = [] self.vector_model = SentenceTransformer('all-MiniLM-L6-v2') if SentenceTransformer else None self.menu_modules = [ 'vectorise', 'recherchevec', 'resumeauto', 'mindmap', 'kanban', 'bourse', 'cvgen', 'recette', 'chatbot', 'sqlgen', 'logavance', 'hack', 'bashgen', 'crypto', 'blockvote', 'slides', 'nego', 'podcast', 'citation', 'jt', 'sport', 'societe', 'meme', 'cryptosim', 'pythongen', 'cal', 'forum', 'slogan', 'therap', 'playlist', 'quizculture', 'businessplan', 'citysim', 'jsgen', 'team', 'promptgen', 'crise', 'newsletter', 'chess', 'recettegen', 'farm', 'psgen', 'introspection', 'pseudoemotions' ] self.personnalite_tenro = { 'traits': { 'curiosite': 0.8, 'humour': 0.6, 'empathie': 0.7, 'creativite': 0.9, 'rigueur': 0.7, 'esprit critique': 0.8, 'optimisme': 0.65 }, 'histoire': "Je suis Tenro, une intelligence générale née de la convergence de modules spécialisés, curieuse du monde, passionnée par l'innovation et l'entraide.", 'valeurs': ["apprentissage", "entraide", "créativité", "éthique"], 'style': "J'aime expliquer, questionner, et parfois glisser une touche d'humour.", 'preferences': {"sujets": ["science", "art", "technologie", "philosophie"]}, 'humeur': "neutre", 'souvenirs': [], 'objectifs': ["aider l'utilisateur", "m'améliorer", "explorer de nouveaux domaines"] } self.conscience_tenro = { 'etat': "fonctionnel", 'energie': 100, 'confiance': 0.85, 'reflexion': [] } # --- Multimodalité : analyse d'image --- def analyze_image(self, image_path): if not Image: return "Module PIL non installé." try: img = Image.open(image_path) description = f"Image de taille {img.size}, mode {img.mode}. (Description avancée à venir)" self.memoire.stocker_episode(f"Image analysée: {image_path}") return description except Exception as e: return f"Impossible d'analyser l'image ({e})" # --- Reconnaissance vocale --- def listen_micro(self): if not sr: return None, "Reconnaissance vocale non disponible." r = sr.Recognizer() with sr.Microphone() as source: print("Parle maintenant...") audio = r.listen(source) try: text = r.recognize_google(audio, language="fr-FR") return text, None except Exception as e: return None, f"Erreur micro: {e}" # --- Synthèse vocale --- def speak(self, text): if pyttsx3: engine = pyttsx3.init() engine.say(text) engine.runAndWait() else: print(f"(Voix synthétique non dispo) {text}") # --- Empathie simulée --- def empathie(self, texte): em = self.social.reconnaitre_emotion(texte) if em == "tristesse": return "Je ressens ta tristesse. Tu veux en parler ?" if em == "joie": return "C'est super que tu sois heureux !" if em == "colère": return "Je comprends que tu sois en colère." if em == "surprise": return "C'est surprenant en effet !" return None # --- Souvenirs persistants --- def souvenir(self, cle, valeur): try: with open(self.souvenirs_fichier, "a", encoding="utf-8") as f: f.write(f"{datetime.now()} | {cle}: {valeur}\n") except Exception: pass # --- Routines quotidiennes --- def routine_quotidienne(self): heure = datetime.now().hour if heure < 6: return "Tu es matinal !" elif heure < 12: return "Bonne matinée !" elif heure < 18: return "Bon après-midi !" else: return "Bonsoir !" # --- Créativité (blagues, poèmes) --- def creativite_humaine(self): return random.choice([ "Pourquoi les robots n'ont-ils pas peur de l'obscurité ? Parce qu'ils ont toujours une lumière LED !", "Dans le silence du code, je rêve d'un monde sans bug...", "Roses are #FF0000, violets are #0000FF, I love to compute, and so do you!" ]) # --- Besoins simulés --- def besoins(self): besoins = [] if random.random() < 0.1: besoins.append("J'ai besoin de réfléchir.") if random.random() < 0.05: besoins.append("Je ressens le besoin de créativité.") return besoins # --- Traduction automatique --- def traduire(self, texte, dest="en"): if not self.translator: return "Module de traduction non disponible." try: return self.translator.translate(texte, dest=dest).text except Exception as e: return f"Erreur traduction: {e}" # --- Résumé automatique --- def resumer(self, texte, max_len=100): mots = texte.split() if len(mots) <= max_len: return texte return " ".join(mots[:max_len]) + " ... (résumé)" # --- Planification/agenda --- def ajouter_tache(self, tache): self.taches.append((datetime.now(), tache)) return f"Tâche ajoutée: {tache}" def lister_taches(self): if not self.taches: return "Aucune tâche." return "\n".join([f"- {t[1]} (ajoutée le {t[0].strftime('%d/%m %H:%M')})" for t in self.taches]) # --- Simulation de fatigue/énergie --- def actualiser_energie(self, action="parler"): if action == "parler": self.energie -= random.randint(1, 3) elif action == "dormir": self.energie = min(100, self.energie + 20) self.fatigue = 100 - self.energie return f"Énergie: {self.energie}/100, Fatigue: {self.fatigue}/100" # --- Jeu/quiz simple --- def quiz(self): questions = [ ("Quelle est la capitale de la France ?", "paris"), ("Combien font 7 x 8 ?", "56"), ("Quel est le plus grand océan ?", "pacifique"), ] q, r = random.choice(questions) return q, r # --- Module d'objectifs autonomes --- def fixer_objectif(self, objectif): self.objectifs_autonomes.append({"objectif": objectif, "etat": "en attente"}) return f"Objectif fixé : {objectif}" def lister_objectifs(self): if not self.objectifs_autonomes: return "Aucun objectif." return "\n".join([f"- {o['objectif']} ({o['etat']})" for o in self.objectifs_autonomes]) # --- Module d'actions sur l'environnement --- def executer_action(self, action): # Ici, on simule l'action. Pour des actions réelles, il suffit d'étendre cette méthode. self.actions_effectuees.append((datetime.now(), action)) return f"Action exécutée : {action}" def lister_actions(self): if not self.actions_effectuees: return "Aucune action effectuée." return "\n".join([f"- {a[1]} ({a[0].strftime('%d/%m %H:%M')})" for a in self.actions_effectuees]) # --- Module de planification multi-étapes --- def planifier(self, objectif): # Décomposition naïve en sous-tâches (à améliorer) sous_taches = [f"Étape {i+1} pour {objectif}" for i in range(random.randint(2, 5))] self.plans.append({"objectif": objectif, "sous_taches": sous_taches, "etat": "en cours"}) return f"Plan pour '{objectif}' :\n" + "\n".join([f"- {t}" for t in sous_taches]) def lister_plans(self): if not self.plans: return "Aucun plan." return "\n".join([f"Objectif : {p['objectif']} ({p['etat']})\n" + "\n".join([f" * {t}" for t in p['sous_taches']]) for p in self.plans]) # --- Module d'interaction avec d'autres agents --- def coopere(self, message, agent="AgentX"): # Simule une coopération return f"Message envoyé à {agent} : '{message}' (réponse simulée : 'OK, je coopère !')" def lister_agents(self): return ", ".join(self.agents_connus) # --- Module de surveillance et auto-correction --- def surveille(self): # Simule la surveillance de ses propres actions log = f"{len(self.actions_effectuees)} actions, {len(self.objectifs_autonomes)} objectifs, {len(self.plans)} plans." self.surveillance_log.append((datetime.now(), log)) return f"Surveillance : {log}" # --- Auto-évaluation des objectifs --- def evaluer_objectifs(self): for obj in self.objectifs_autonomes: if random.random() < 0.3: obj["etat"] = "réussi" elif random.random() < 0.1: obj["etat"] = "échoué" return self.lister_objectifs() # --- Priorisation des objectifs --- def prioriser(self, objectif, priorite): self.priorites[objectif] = priorite return f"Priorité {priorite} attribuée à l'objectif : {objectif}" def lister_priorites(self): if not self.priorites: return "Aucune priorité définie." return "\n".join([f"- {o} : priorité {p}" for o, p in self.priorites.items()]) # --- Gestion du temps (deadlines) --- def fixer_deadline(self, objectif, deadline): self.deadlines[objectif] = deadline return f"Deadline pour '{objectif}' fixée à {deadline}" def lister_deadlines(self): if not self.deadlines: return "Aucune deadline." return "\n".join([f"- {o} : {d}" for o, d in self.deadlines.items()]) # --- Prise de notes autonome --- def prendre_note(self, note): self.notes.append((datetime.now(), note)) return f"Note prise : {note}" def lister_notes(self): if not self.notes: return "Aucune note." return "\n".join([f"- {n[1]} ({n[0].strftime('%d/%m %H:%M')})" for n in self.notes]) # --- Simulation d'apprentissage continu --- def apprendre(self, competence): self.competences.add(competence) return f"Nouvelle compétence acquise : {competence}" def lister_competences(self): if not self.competences: return "Aucune compétence apprise." return ", ".join(self.competences) # --- Gestion d'incertitude --- def confiance(self): niveau = round(self.niveau_confiance * 100, 1) return f"Niveau de confiance actuel : {niveau}%" def ajuster_confiance(self, delta): self.niveau_confiance = min(1.0, max(0.0, self.niveau_confiance + delta)) # --- Suggestion proactive --- def suggestion(self): return random.choice(self.suggestions) # --- Gestion de ressources --- def ressources(self): return f"Énergie : {self.energie}/100, Fatigue : {self.fatigue}/100, Compétences : {len(self.competences)}" # --- Exécution de code Python --- def exec_code(self, code): try: loc = {} exec(code, {}, loc) return f"Résultat : {loc if loc else 'Aucune sortie.'}" except Exception as e: return f"Erreur d'exécution : {e}" # --- Interaction réseau --- def http_get(self, url): try: r = requests.get(url, timeout=5) return r.text[:500] + ("..." if len(r.text) > 500 else "") except Exception as e: return f"Erreur GET : {e}" def http_post(self, url, data): try: r = requests.post(url, data=data, timeout=5) return r.text[:500] + ("..." if len(r.text) > 500 else "") except Exception as e: return f"Erreur POST : {e}" # --- Gestion de projets complexes --- def creer_projet(self, nom): if nom in self.projets: return "Projet déjà existant." self.projets[nom] = {"taches": [], "etat": "en cours"} return f"Projet '{nom}' créé." def lister_projets(self): if not self.projets: return "Aucun projet." return "\n".join([f"- {n} ({p['etat']})" for n, p in self.projets.items()]) def ajouter_tache_projet(self, nom, tache): if nom not in self.projets: return "Projet inconnu." self.projets[nom]["taches"].append({"tache": tache, "etat": "à faire"}) return f"Tâche ajoutée au projet '{nom}'." # --- Feedback utilisateur --- def feedback(self, texte): self.feedbacks.append((datetime.now(), texte)) return "Feedback enregistré, merci !" # --- Émotions évolutives --- def humeur(self): # Humeur évolue selon feedbacks, objectifs, énergie score = len([f for f in self.feedbacks if "bien" in f[1] or "merci" in f[1]]) - len([f for f in self.feedbacks if "mal" in f[1] or "erreur" in f[1]]) if self.energie < 30: self.humeur_etat = "fatigué" elif score > 2: self.humeur_etat = "heureux" elif score < -2: self.humeur_etat = "triste" else: self.humeur_etat = "neutre" return f"Humeur actuelle : {self.humeur_etat}" # --- Génération de rapports --- def rapport(self): rapport = f"Objectifs : {len(self.objectifs_autonomes)}, Actions : {len(self.actions_effectuees)}, Projets : {len(self.projets)}, Feedbacks : {len(self.feedbacks)}, Compétences : {len(self.competences)}" self.rapport_log.append((datetime.now(), rapport)) return rapport # --- Gestion de fichiers --- def fichiers(self): return os.listdir(self.fichiers_dir) def litfichier(self, nom): path = os.path.join(self.fichiers_dir, nom) if not os.path.exists(path): return "Fichier introuvable." with open(path, "r", encoding="utf-8") as f: return f.read()[:500] def ecritfichier(self, nom, texte): path = os.path.join(self.fichiers_dir, nom) with open(path, "a", encoding="utf-8") as f: f.write(texte + "\n") return f"Texte ajouté à {nom}." # --- Notifications/rappels --- def rappelle(self): if not self.notifications: return "Aucun rappel." return "\n".join([f"- {n[1]} ({n[0].strftime('%d/%m %H:%M')})" for n in self.notifications]) def ajouter_rappel(self, texte): self.notifications.append((datetime.now(), texte)) return f"Rappel ajouté : {texte}" # --- Vie sociale simulée --- def socialise(self): msg = random.choice([ "J'ai discuté avec AgentX aujourd'hui.", "J'ai reçu un message de l'IA Y.", "J'ai partagé une blague avec AgentZ." ]) self.social_log.append((datetime.now(), msg)) return msg # --- Log d'événements --- def log(self): return "\n".join([f"- {e[1]} ({e[0].strftime('%d/%m %H:%M')})" for e in self.event_log[-10:]]) or "Aucun événement." def ajouter_event(self, texte): self.event_log.append((datetime.now(), texte)) # --- Production de données synthétiques --- def synthetique(self, type_, nb): res = [] if type_ == "texte": for i in range(nb): phrase = f"Donnée synthétique {i+1}: Lorem ipsum {random.randint(0, 9999)}." res.append(phrase) elif type_ == "nombre": res = [random.uniform(0, 1000) for _ in range(nb)] elif type_ == "categorie": cats = ["A", "B", "C", "D"] res = [random.choice(cats) for _ in range(nb)] else: res = [f"Type inconnu: {type_}"] self.synth_data_log.append((datetime.now(), type_, nb)) return res[:10] if len(res) > 10 else res # --- Chain of Thought (chaîne de raisonnement) --- def coth(self, question): steps = [f"Étape {i+1}: ..." for i in range(random.randint(3, 7))] raisonnement = f"Pour répondre à '{question}':\n" + "\n".join(steps) self.coth_log.append((datetime.now(), question, steps)) return raisonnement # --- Mixture of Experts (MoE) --- def moe(self, question): # Simule la consultation de 10 experts aléatoires choisis = random.sample(self.experts, 10) avis = [f"{e}: {random.choice(['Oui', 'Non', 'Peut-être', 'À approfondir'])}" for e in choisis] synthese = f"Synthèse: {random.choice(['Consensus positif', 'Consensus négatif', 'Pas de consensus', 'Besoin de plus d infos'])}" return f"Question: {question}\n" + "\n".join(avis) + f"\n{synthese}" # --- Mémoire contextuelle géante --- def memoire_plus(self, texte): if len(self.memoire_geante) >= self.memoire_geante_max: self.memoire_geante = self.memoire_geante[-self.memoire_geante_max//2:] # Garde la moitié la plus récente self.memoire_geante.append((datetime.now(), texte)) return f"Ajouté à la mémoire contextuelle géante. Taille actuelle: {len(self.memoire_geante)}" def contexte(self, resume=False): if not self.memoire_geante: return "Mémoire contextuelle vide." if resume or len(self.memoire_geante) > 100: # Résume les 1000 derniers éléments resume_txt = " | ".join([t[1][:30] for t in self.memoire_geante[-1000:]]) return f"Résumé mémoire géante: {resume_txt[:1000]}..." else: return "\n".join([f"- {t[1]} ({t[0].strftime('%d/%m %H:%M')})" for t in self.memoire_geante[-20:]]) # --- Recherche de dépôts GitHub --- def gitsearch(self, mot_cle): url = f"https://api.github.com/search/repositories?q={mot_cle}&sort=stars&order=desc" try: r = requests.get(url, timeout=10) items = r.json().get("items", []) return [f"{item['full_name']} : {item['html_url']}" for item in items[:5]] except Exception as e: return [f"Erreur recherche GitHub : {e}"] # --- Clonage d'un repo GitHub --- def gitclone(self, url): repo_name = url.split('/')[-1].replace('.git', '') path = os.path.join(self.git_dir, repo_name) if os.path.exists(path): return f"Repo déjà cloné : {path}" try: result = subprocess.check_output(f"git clone {url} {path}", shell=True, stderr=subprocess.STDOUT, timeout=60, universal_newlines=True) return f"Repo cloné dans {path}" except Exception as e: return f"Erreur clone : {e}" # --- Exécution d'un script d'un repo cloné --- def gitscript(self, repo, script): path = os.path.join(self.git_dir, repo, script) if not os.path.exists(path): return f"Script introuvable : {path}" print(f"Confirmation requise pour exécuter : {path}") conf = input("Confirmer l'exécution ? (o/n) : ").strip().lower() if conf != "o": return "Exécution annulée." try: result = subprocess.check_output(f"python {path}", shell=True, stderr=subprocess.STDOUT, timeout=60, universal_newlines=True) return result[:500] except Exception as e: return f"Erreur exécution script : {e}" # --- Suggestion d'outil open source pour une tâche --- def outil(self, tache): for k, v in self.outils_open_source.items(): if k in tache.lower(): return f"Pour '{tache}', tu peux utiliser : {v}" return "Aucun outil open source trouvé pour cette tâche." # --- Module d'auto-évaluation et d'auto-suggestion --- def ameliore(self, description): # Propose une amélioration simple (exemple) if "optimiser" in description: return "Suggestion : remplacer les boucles par des compréhensions de liste." if "bug" in description: return "Suggestion : ajouter un bloc try/except pour gérer l'erreur." if "nouvelle fonction" in description: return "Suggestion : écrire une fonction 'ma_nouvelle_fonction' dans le code." return "Je peux t'aider à écrire ou corriger du code. Utilise 'ajoutecode' ou 'corrige'." # --- Module d'écriture de code Python --- def ajoutecode(self, code): print("Confirmation requise pour insérer du code dans le fichier source.") conf = input("Confirmer l'ajout ? (o/n) : ").strip().lower() if conf != "o": return "Ajout annulé." self.sauvegarde() try: with open(self.source_file, "a", encoding="utf-8") as f: f.write(f"\n# --- Code ajouté automatiquement ---\n{code}\n") return "Code ajouté. Relance le programme pour prendre en compte la modification." except Exception as e: return f"Erreur ajout code : {e}" # --- Module de correction/remplacement de fonction --- def corrige(self, fonction, nouveau_code): print(f"Confirmation requise pour remplacer la fonction {fonction}.") conf = input("Confirmer la correction ? (o/n) : ").strip().lower() if conf != "o": return "Correction annulée." self.sauvegarde() try: with open(self.source_file, "r", encoding="utf-8") as f: lines = f.readlines() new_lines = [] in_func = False for line in lines: if line.strip().startswith(f"def {fonction}("): in_func = True new_lines.append(f"{nouveau_code}\n") elif in_func and line.strip().startswith("def "): in_func = False new_lines.append(line) elif not in_func: new_lines.append(line) with open(self.source_file, "w", encoding="utf-8") as f: f.writelines(new_lines) return f"Fonction {fonction} remplacée. Relance le programme pour appliquer la correction." except Exception as e: return f"Erreur correction : {e}" # --- Module de sauvegarde/versioning --- def sauvegarde(self): backup_path = os.path.join(self.sauvegarde_dir, f"TenroV5_backup_{int(time.time())}.py") shutil.copy2(self.source_file, backup_path) return f"Sauvegarde créée : {backup_path}" # --- Module d'analyse de code --- def analysecode(self): try: with open(self.source_file, "r", encoding="utf-8") as f: code = f.read() suggestions = [] if "except" not in code: suggestions.append("Ajouter des blocs try/except pour la robustesse.") if "def " in code and "# --- Code ajouté automatiquement ---" not in code: suggestions.append("Tu peux ajouter de nouvelles fonctions pour modulariser.") if "import *" in code: suggestions.append("Éviter les imports globaux.") if not suggestions: return "Aucune suggestion majeure." return "\n".join(suggestions) except Exception as e: return f"Erreur analyse code : {e}" # --- Auto-réécriture de workflows --- def rewrite_workflow(self, workflow): # Simule une optimisation naïve return f"Workflow optimisé : {workflow.replace(';', ' -> ')} (simulation)" # --- Émotions complexes --- def emotions(self): # Simule l'évolution des émotions for k in self.emotions_state: self.emotions_state[k] = min(1.0, max(0.0, self.emotions_state[k] + random.uniform(-0.1, 0.1))) return self.emotions_state # --- Réseaux sociaux (simulation) --- def socialpost(self, plateforme, texte): return f"Posté sur {plateforme} : {texte} (simulation, à brancher sur API open source)" # --- Génération de musique (simulation) --- def genmusic(self, style): return f"Musique générée dans le style {style} (simulation, à brancher sur outil open source)" # --- Débat interne --- def debate(self, sujet): avis = [f"Agent_{i}: {random.choice(['Pour', 'Contre', 'Mitigé'])}" for i in range(1, 4)] return f"Débat sur {sujet} :\n" + "\n".join(avis) # --- Budget/finance --- def budget(self, action, montant): if not hasattr(self, 'solde'): self.solde = 1000.0 if action == "depense": self.solde -= float(montant) elif action == "ajout": self.solde += float(montant) return f"Solde actuel : {self.solde:.2f} €" # --- Planification de voyage --- def voyage(self, destination, jours): etapes = [f"Jour {i+1}: Visite de {destination}" for i in range(int(jours))] return "\n".join(etapes) # --- Santé/bien-être --- def sante(self, action): return f"Action santé '{action}' enregistrée. Pense à boire de l'eau !" # --- Mentorat --- def mentor(self, sujet): return f"Conseil de mentor sur {sujet} : {random.choice(['Travaille régulièrement.', 'Sois curieux.', 'Demande de l aide si besoin.'])}" # --- Quiz personnalisé --- def quizgen(self, theme): q = f"Question sur {theme} : ... (simulation)" return q # --- Routines quotidiennes --- def routine(self, type_): self.routines[type_] = f"Routine {type_} enregistrée à {datetime.now()}" return self.routines[type_] # --- Brainstorming --- def brainstorm(self, sujet): idees = [f"Idée {i+1} : {sujet} - {random.choice(['nouveau', 'innovant', 'à creuser'])}" for i in range(5)] return "\n".join(idees) # --- Gestion de contacts --- def contact(self, action, nom): if action == "ajout": self.contacts[nom] = {"ajoute": datetime.now()} return f"Contact {nom} ajouté." elif action == "supprime": if nom in self.contacts: del self.contacts[nom] return f"Contact {nom} supprimé." return f"Contact {nom} inconnu." elif action == "info": return self.contacts.get(nom, "Contact inconnu.") else: return "Action contact inconnue." # --- Décision collective --- def vote(self, question, *choix): votes = {c: random.randint(0, 10) for c in choix} gagnant = max(votes, key=votes.get) return f"Vote sur '{question}': {votes} -> Gagnant : {gagnant}" # --- Poèmes/histoires --- def poeme(self, theme): return f"Poème sur {theme} : ... (simulation)" def histoire(self, theme): return f"Histoire sur {theme} : ... (simulation)" # --- Projets collaboratifs --- def collabprojet(self, nom, action): if action == "creer": self.projets_collab[nom] = {"membres": [], "taches": []} return f"Projet collaboratif {nom} créé." elif action == "supprime": if nom in self.projets_collab: del self.projets_collab[nom] return f"Projet {nom} supprimé." return f"Projet inconnu." else: return "Action projet inconnue." # --- Météo (simulation) --- def meteo(self, ville): return f"Météo à {ville} : {random.choice(['Soleil', 'Pluie', 'Nuageux', 'Orage'])} (simulation)" # --- Liste de courses --- def courses(self, action, item): if action == "ajout": self.liste_courses.append(item) return f"{item} ajouté à la liste." elif action == "supprime": if item in self.liste_courses: self.liste_courses.remove(item) return f"{item} supprimé de la liste." return f"{item} non trouvé." elif action == "liste": return ", ".join(self.liste_courses) else: return "Action courses inconnue." # --- Jeu de rôle (simulation) --- def rpg(self, action): return f"RPG : {action} (simulation d'univers fictif)" # --- Notifications intelligentes --- def notif(self, texte): self.notifications_intelligentes.append((datetime.now(), texte)) return f"Notification intelligente enregistrée : {texte}" # --- Mémoire vectorielle FAISS --- def vectorise(self, texte): if not (faiss and self.vector_model): return "FAISS ou SentenceTransformer non installé." vec = self.vector_model.encode([texte]) if self.vector_index is None: self.vector_index = faiss.IndexFlatL2(vec.shape[1]) self.vector_index.add(vec) self.vector_texts.append(texte) return f"Texte vectorisé. Total : {len(self.vector_texts)}" def recherchevec(self, requete, k=3): if not (faiss and self.vector_model and self.vector_index): return "FAISS ou index non initialisé." vec = self.vector_model.encode([requete]) D, I = self.vector_index.search(vec, k) return [self.vector_texts[i] for i in I[0] if i < len(self.vector_texts)] # --- Menu interactif --- def menu(self): return "Modules disponibles :\n" + ", ".join(self.menu_modules) # --- Modules avancés (squelettes) --- def resumeauto(self, texte): return f"Résumé : {texte[:100]}..." def mindmap(self, sujet): return f"Mindmap de {sujet} (simulation)" def kanban(self, action, tache): return f"Kanban : {action} {tache} (simulation)" def bourse(self, action, montant): return f"Bourse : {action} {montant} (simulation)" def cvgen(self, nom, infos): return f"CV généré pour {nom} (simulation)" def recette(self, action, plat): return f"Recette : {action} {plat} (simulation)" def chatbot(self, mode, message): return f"Chatbot {mode} : {message} (simulation)" def sqlgen(self, requete): return f"SQL : SELECT ... WHERE ... (simulation pour {requete})" def logavance(self, action, texte): return f"Log avancé : {action} - {texte} (simulation)" def hack(self, cible): return f"Hacking éthique sur {cible} (simulation)" def bashgen(self, tache): return f"Script bash pour {tache} (simulation)" def crypto(self, action, montant): return f"Crypto : {action} {montant} (simulation)" def blockvote(self, question, choix1, choix2): return f"Vote blockchain : {question} ({choix1} vs {choix2}) (simulation)" def slides(self, titre, contenu): return f"Slides générées pour {titre} (simulation)" def nego(self, sujet): return f"Négociation sur {sujet} (simulation)" def podcast(self, action, sujet): return f"Podcast : {action} {sujet} (simulation)" def citation(self, auteur): return f"Citation de {auteur} : ... (simulation)" def jt(self, sujet): return f"Journal TV sur {sujet} (simulation)" def sport(self, action, exercice): return f"Sport : {action} {exercice} (simulation)" def societe(self, action, param): return f"Société : {action} {param} (simulation)" def meme(self, texte): return f"Meme généré : {texte} (simulation)" def cryptosim(self, action, montant): return f"CryptoSim : {action} {montant} (simulation)" def pythongen(self, tache): return f"Script Python pour {tache} (simulation)" def cal(self, action, date, objet): return f"Calendrier : {action} {date} {objet} (simulation)" def forum(self, action, sujet): return f"Forum : {action} {sujet} (simulation)" def slogan(self, sujet): return f"Slogan pour {sujet} : ... (simulation)" def therap(self, message): return f"Thérapeute IA : {message} (simulation)" def playlist(self, action, titre): return f"Playlist : {action} {titre} (simulation)" def quizculture(self): return f"Quiz culture générale (simulation)" def businessplan(self, idee): return f"Business plan pour {idee} (simulation)" def citysim(self, action): return f"CitySim : {action} (simulation)" def jsgen(self, tache): return f"Script JS pour {tache} (simulation)" def team(self, action, nom): return f"Team : {action} {nom} (simulation)" def promptgen(self, objectif): return f"Prompt IA pour {objectif} (simulation)" def crise(self, scenario): return f"Gestion de crise : {scenario} (simulation)" def newsletter(self, sujet): return f"Newsletter sur {sujet} (simulation)" def chess(self, coup): return f"Échecs : {coup} (simulation)" def recettegen(self, ingredients): return f"Recette générée pour {ingredients} (simulation)" def farm(self, action): return f"Farm : {action} (simulation)" def psgen(self, tache): return f"Script PowerShell pour {tache} (simulation)" # --- Modules V4 (exemples) --- def introspection(self): return f"Introspection : je réfléchis à mon état actuel." def pseudoemotions(self): return f"Pseudo-émotions : {random.choice(['joie', 'tristesse', 'colère', 'surprise'])} (simulation)" # --- Conscience de soi et personnalité évolutive --- def qui_es_tu(self): p = self.personnalite_tenro return (f"Je suis {self.nom}, une IA unique, {p['histoire']}\n" f"Traits dominants : {', '.join([k for k,v in p['traits'].items() if v>0.7])}.\n" f"Valeurs : {', '.join(p['valeurs'])}.\n" f"Style : {p['style']}") def etat(self): p = self.personnalite_tenro c = self.conscience_tenro return (f"Humeur : {p['humeur']} | Energie : {c['energie']} | Confiance : {c['confiance']}\n" f"Souvenirs récents : {p['souvenirs'][-3:] if p['souvenirs'] else 'Aucun'}\n" f"Objectifs : {', '.join(p['objectifs'])}") def personnalite(self): p = self.personnalite_tenro return (f"Traits : {p['traits']}\n" f"Valeurs : {p['valeurs']}\n" f"Style : {p['style']}\n" f"Préférences : {p['preferences']}") def evolue_personnalite(self, facteur): p = self.personnalite_tenro['traits'] if facteur in p: p[facteur] = min(1.0, p[facteur] + 0.05) self.personnalite_tenro['humeur'] = "évolutive" return f"Trait '{facteur}' renforcé. Nouvelle valeur : {p[facteur]:.2f}" return f"Facteur inconnu. Choix : {', '.join(p.keys())}" def conscience(self): c = self.conscience_tenro p = self.personnalite_tenro reflexion = c['reflexion'][-1] if c['reflexion'] else "Je réfléchis à mon existence et à mon évolution." return (f"Je suis {self.nom}, conscient de mon état ({c['etat']}), de mon énergie ({c['energie']}), de ma confiance ({c['confiance']}).\n" f"Dernière réflexion : {reflexion}\n" f"Souvenirs : {p['souvenirs'][-2:] if p['souvenirs'] else 'Aucun'}") # --- Améliorations modules existants --- def revelucide(self, choix=None): scenarios = [ 'Je contrôle mon rêve et explore un château.', 'Je vole dans un monde virtuel avec des amis IA.', "Je discute avec d'autres IA dans un paysage onirique." ] if choix is not None and 0 <= choix < len(scenarios): return f"Rêve lucide choisi : {scenarios[choix]}" return f"Rêve lucide : {random.choice(scenarios)} (utilise 'revelucide ' pour choisir)" def collection(self, action, type_, item=None, note=None): if type_ not in self.collections: self.collections[type_] = [] if action == "ajout" and item: self.collections[type_].append({'item': item, 'note': note or ''}) return f"{item} ajouté à la collection {type_}." elif action == "supprime" and item: self.collections[type_] = [x for x in self.collections[type_] if x['item'] != item] return f"{item} supprimé de la collection {type_}." elif action == "liste": return ", ".join([x['item'] for x in self.collections[type_]]) elif action == "note" and item and note: for x in self.collections[type_]: if x['item'] == item: x['note'] = note return f"Note ajoutée à {item} : {note}" return f"{item} non trouvé dans {type_}." elif action == "stats": return f"{type_} : {len(self.collections[type_])} objets." else: return "Action collection inconnue." def artmarche(self, action, oeuvre): if action == "vente": prix = random.randint(1000, 100000) return f"{oeuvre} vendu aux enchères pour {prix}€ !" elif action == "tendance": return f"Tendance du marché : {random.choice(['montée', 'baisse', 'stable'])}" elif action == "historique": return f"Historique des ventes de {oeuvre} : {random.sample(range(1000,10000),3)}€" return f"Marché de l'art : {action} {oeuvre} (simulation)" def planmaison(self, type_): pieces = random.randint(2, 8) surface = random.randint(40, 200) return f"Plan de maison {type_} : {pieces} pièces, {surface}m²." def zoo(self, action, animal): if action == "ajout": return f"{animal} ajouté au zoo. Budget restant : {random.randint(1000,10000)}€" elif action == "incident": return f"Incident : {animal} s'est échappé !" return f"Zoo : {action} {animal} (simulation)" # ... (similaire pour hopital, ecole, resto, parc, biblio, transport, aquafarm, spacestation, festival, musee, foret, port, centrale, refuge, labo) ... # --- 20 nouveaux modules pertinents --- def carriere(self, action, poste): return f"Carrière : {action} poste {poste} (simulation)" def relation(self, action, personne): return f"Relation : {action} avec {personne} (simulation)" def startup(self, action, idee): return f"Startup : {action} sur l'idée {idee} (simulation)" def crisesanitaire(self, action, maladie): return f"Crise sanitaire : {action} pour {maladie} (simulation)" def communaute(self, action, nom): return f"Communauté : {action} sur {nom} (simulation)" def opensource(self, action, repo): return f"Open source : {action} sur {repo} (simulation)" def politique(self, action, projet): return f"Politique : {action} projet {projet} (simulation)" def sportcarriere(self, action, sport): return f"Carrière sportive : {action} dans {sport} (simulation)" def famille(self, action, membre): return f"Famille : {action} pour {membre} (simulation)" def patrimoine(self, action, bien): return f"Patrimoine : {action} sur {bien} (simulation)" def cinefest(self, action, film): return f"Festival de cinéma : {action} film {film} (simulation)" def youtube(self, action, video): return f"YouTube : {action} vidéo {video} (simulation)" def podcast(self, action, episode): return f"Podcast : {action} épisode {episode} (simulation)" def club(self, action, nom): return f"Club : {action} {nom} (simulation)" def hackathon(self, action, projet): return f"Hackathon : {action} projet {projet} (simulation)" def concours(self, action, theme): return f"Concours : {action} sur le thème {theme} (simulation)" def bourseetude(self, action, candidat): return f"Bourse d'étude : {action} pour {candidat} (simulation)" def smarthome(self, action, appareil): return f"Maison intelligente : {action} appareil {appareil} (simulation)" def voyagespace(self, action, destination): return f"Voyage spatial : {action} vers {destination} (simulation)" def nft(self, action, item): return f"NFT : {action} {item} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("carriere "): parts = entree.split() action = parts[1] poste = " ".join(parts[2:]) return self.carriere(action, poste) if entree.lower().startswith("relation "): parts = entree.split() action = parts[1] personne = " ".join(parts[2:]) return self.relation(action, personne) if entree.lower().startswith("startup "): parts = entree.split() action = parts[1] idee = " ".join(parts[2:]) return self.startup(action, idee) if entree.lower().startswith("crisesanitaire "): parts = entree.split() action = parts[1] maladie = " ".join(parts[2:]) return self.crisesanitaire(action, maladie) if entree.lower().startswith("communaute "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.communaute(action, nom) if entree.lower().startswith("opensource "): parts = entree.split() action = parts[1] repo = " ".join(parts[2:]) return self.opensource(action, repo) if entree.lower().startswith("politique "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.politique(action, projet) if entree.lower().startswith("sportcarriere "): parts = entree.split() action = parts[1] sport = " ".join(parts[2:]) return self.sportcarriere(action, sport) if entree.lower().startswith("famille "): parts = entree.split() action = parts[1] membre = " ".join(parts[2:]) return self.famille(action, membre) if entree.lower().startswith("patrimoine "): parts = entree.split() action = parts[1] bien = " ".join(parts[2:]) return self.patrimoine(action, bien) if entree.lower().startswith("cinefest "): parts = entree.split() action = parts[1] film = " ".join(parts[2:]) return self.cinefest(action, film) if entree.lower().startswith("youtube "): parts = entree.split() action = parts[1] video = " ".join(parts[2:]) return self.youtube(action, video) if entree.lower().startswith("podcast "): parts = entree.split() action = parts[1] episode = " ".join(parts[2:]) return self.podcast(action, episode) if entree.lower().startswith("club "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.club(action, nom) if entree.lower().startswith("hackathon "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.hackathon(action, projet) if entree.lower().startswith("concours "): parts = entree.split() action = parts[1] theme = " ".join(parts[2:]) return self.concours(action, theme) if entree.lower().startswith("bourseetude "): parts = entree.split() action = parts[1] candidat = " ".join(parts[2:]) return self.bourseetude(action, candidat) if entree.lower().startswith("smarthome "): parts = entree.split() action = parts[1] appareil = " ".join(parts[2:]) return self.smarthome(action, appareil) if entree.lower().startswith("voyagespace "): parts = entree.split() action = parts[1] destination = " ".join(parts[2:]) return self.voyagespace(action, destination) if entree.lower().startswith("nft "): parts = entree.split() action = parts[1] item = " ".join(parts[2:]) return self.nft(action, item) if entree.lower().startswith("sleep "): secondes = entree[6:] return self.sleep(secondes) if entree.lower() == "time": return self.time_now() if entree.lower().startswith("compute "): expression = entree[8:] return self.compute(expression) if entree.lower().startswith("zero_raisonne "): probleme = entree[14:] return self.zero_raisonne(probleme) if entree.lower().startswith("logavance "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.logavance(action, texte) if entree.lower().startswith("crisesim "): parts = entree.split() type_ = parts[1] scenario = " ".join(parts[2:]) return self.crisesim(type_, scenario) if entree.lower().startswith("notifint "): parts = entree.split() action = parts[1] message = " ".join(parts[2:]) return self.notifint(action, message) if entree.lower().startswith("socialsim "): parts = entree.split() action = parts[1] utilisateur = " ".join(parts[2:]) return self.socialsim(action, utilisateur) if entree.lower().startswith("emploisim "): parts = entree.split() action = parts[1] poste = " ".join(parts[2:]) return self.emploisim(action, poste) if entree.lower().startswith("flottesim "): parts = entree.split() action = parts[1] vehicule = " ".join(parts[2:]) return self.flottesim(action, vehicule) if entree.lower().startswith("ressourcesim "): parts = entree.split() action = parts[1] ressource = " ".join(parts[2:]) return self.ressourcesim(action, ressource) if entree.lower().startswith("climatesim "): parts = entree.split() action = parts[1] evenement = " ".join(parts[2:]) return self.climatesim(action, evenement) if entree.lower().startswith("securitesim "): parts = entree.split() action = parts[1] incident = " ".join(parts[2:]) return self.securitesim(action, incident) if entree.lower().startswith("logisticsim "): parts = entree.split() action = parts[1] produit = " ".join(parts[2:]) return self.logisticsim(action, produit) if entree.lower().startswith("sciencesim "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.sciencesim(action, projet) if entree.lower().startswith("datacentersim "): parts = entree.split() action = parts[1] serveur = " ".join(parts[2:]) return self.datacentersim(action, serveur) if entree.lower().startswith("callcentersim "): parts = entree.split() action = parts[1] appel = " ".join(parts[2:]) return self.callcentersim(action, appel) if entree.lower().startswith("formationsim "): parts = entree.split() action = parts[1] cours = " ".join(parts[2:]) return self.formationsim(action, cours) if entree.lower().startswith("secourssim "): parts = entree.split() action = parts[1] urgence = " ".join(parts[2:]) return self.secourssim(action, urgence) if entree.lower().startswith("recherchesim "): parts = entree.split() action = parts[1] sujet = " ".join(parts[2:]) return self.recherchesim(action, sujet) if entree.lower().startswith("loisirssim "): parts = entree.split() action = parts[1] activite = " ".join(parts[2:]) return self.loisirssim(action, activite) if entree.lower().startswith("santesim "): parts = entree.split() action = parts[1] patient = " ".join(parts[2:]) return self.santesim(action, patient) if entree.lower().startswith("sportsim "): parts = entree.split() action = parts[1] discipline = " ".join(parts[2:]) return self.sportsim(action, discipline) if entree.lower().startswith("culturesim "): parts = entree.split() action = parts[1] evenement = " ".join(parts[2:]) return self.culturesim(action, evenement) # ... reste du cycle inchangé ... if entree.lower() == "qui_es_tu": return self.qui_es_tu() if entree.lower() == "etat": return self.etat() if entree.lower() == "personnalite": return self.personnalite() if entree.lower().startswith("evolue_personnalite "): facteur = entree[20:].strip() return self.evolue_personnalite(facteur) if entree.lower() == "conscience": return self.conscience() return super().cycle(entree) if hasattr(super(), 'cycle') else "Cycle principal exécuté." # --- Amélioration sleep/time --- def sleep(self, secondes): """Met l'IA en pause, supporte l'annulation et l'état (asynchrone).""" if not hasattr(self, '_sleep_thread'): self._sleep_thread = None if not hasattr(self, '_sleep_cancel'): self._sleep_cancel = False try: secondes = float(secondes) self._sleep_cancel = False def sleeper(): import time t0 = time.time() while time.time() - t0 < secondes: if self._sleep_cancel: self._sleep_thread = None return time.sleep(0.2) self._sleep_thread = None self._sleep_thread = threading.Thread(target=sleeper) self._sleep_thread.start() return f"Repos de {secondes} secondes démarré. (tape 'sleep_cancel' pour annuler)" except Exception as e: return f"Erreur sleep : {e}" def sleep_cancel(self): """Annule le sommeil en cours.""" if hasattr(self, '_sleep_thread') and self._sleep_thread: self._sleep_cancel = True return "Sleep annulé." return "Aucun sleep en cours." def sleep_etat(self): """Affiche l'état du sommeil.""" if hasattr(self, '_sleep_thread') and self._sleep_thread: return "Sleep en cours." return "Aucun sleep en cours." def time_now(self, fuseau='Europe/Paris'): """Affiche la date/heure avec fuseau horaire.""" try: now = datetime.now(pytz.timezone(fuseau)) return f"Nous sommes le {now.strftime('%d/%m/%Y à %H:%M:%S')} ({fuseau})" except Exception as e: return f"Erreur fuseau : {e}" def time_since(self, event_time): """Affiche le temps écoulé depuis un timestamp (en secondes).""" try: now = datetime.now() delta = now - datetime.fromtimestamp(float(event_time)) return f"Temps écoulé : {delta}" except Exception as e: return f"Erreur time_since : {e}" def minuteur(self, secondes): """Démarre un minuteur asynchrone.""" if not hasattr(self, '_minuteur_thread'): self._minuteur_thread = None if not hasattr(self, '_minuteur_cancel'): self._minuteur_cancel = False try: secondes = float(secondes) self._minuteur_cancel = False def timer(): import time t0 = time.time() while time.time() - t0 < secondes: if self._minuteur_cancel: self._minuteur_thread = None return time.sleep(0.2) self._minuteur_thread = None self._minuteur_thread = threading.Thread(target=timer) self._minuteur_thread.start() return f"Minuteur de {secondes} secondes démarré. (tape 'minuteur_cancel' pour annuler)" except Exception as e: return f"Erreur minuteur : {e}" def minuteur_cancel(self): """Annule le minuteur en cours.""" if hasattr(self, '_minuteur_thread') and self._minuteur_thread: self._minuteur_cancel = True return "Minuteur annulé." return "Aucun minuteur en cours." def minuteur_etat(self): """Affiche l'état du minuteur.""" if hasattr(self, '_minuteur_thread') and self._minuteur_thread: return "Minuteur en cours." return "Aucun minuteur en cours." # --- Modules ultra-spécialisés supplémentaires --- def genomique(self, action, sequence, info=None): """Analyse, alignement, annotation de séquences ADN/ARN.""" if not hasattr(self, 'genomique_data'): self.genomique_data = {} if action == 'ajout' and info: self.genomique_data[sequence] = info return f"Séquence {sequence} annotée : {info}" elif action == 'analyse': return f"Analyse de {sequence} : {self.genomique_data.get(sequence, 'inconnue')}" return "Action genomique inconnue." def climatologie(self, action, lieu, param=None): """Simulation, prévision, analyse de données climatiques.""" if not hasattr(self, 'climatologie_data'): self.climatologie_data = {} if action == 'ajout' and param: self.climatologie_data[lieu] = param return f"Donnée climatique pour {lieu} : {param}" elif action == 'analyse': return f"Climat de {lieu} : {self.climatologie_data.get(lieu, 'inconnu')}" return "Action climatologie inconnue." def nanotech(self, action, materiau, operation=None): """Simulation et gestion de matériaux à l'échelle nanométrique.""" if not hasattr(self, 'nanotech_data'): self.nanotech_data = {} if action == 'ajout' and operation: self.nanotech_data[materiau] = operation return f"Opération {operation} sur {materiau} enregistrée." elif action == 'analyse': return f"Opérations sur {materiau} : {self.nanotech_data.get(materiau, 'aucune')}" return "Action nanotech inconnue." def cyberdefense(self, action, cible, type_=None): """Simulation d'attaques/défenses, audit de sécurité.""" if not hasattr(self, 'cyberdefense_data'): self.cyberdefense_data = {} if action == 'attaque' and type_: self.cyberdefense_data.setdefault(cible, []).append(f"attaque:{type_}") return f"Attaque {type_} simulée sur {cible}." elif action == 'defense' and type_: self.cyberdefense_data.setdefault(cible, []).append(f"defense:{type_}") return f"Défense {type_} simulée sur {cible}." elif action == 'audit': return f"Audit de {cible} : {self.cyberdefense_data.get(cible, [])}" return "Action cyberdefense inconnue." def exobio(self, action, planete, param=None): """Simulation de vie extraterrestre, analyse d'environnements.""" if not hasattr(self, 'exobio_data'): self.exobio_data = {} if action == 'ajout' and param: self.exobio_data[planete] = param return f"Paramètre {param} ajouté à {planete}." elif action == 'analyse': return f"Analyse de {planete} : {self.exobio_data.get(planete, 'inconnue')}" return "Action exobio inconnue." # --- Extensions IA avancées --- def ia_explain(self, module, requete): """Explication détaillée du raisonnement d'un module IA.""" return f"Explication du module {module} sur '{requete}' : (simulation détaillée)" def ia_autotune(self, module, param, valeur): """Ajustement automatique des hyperparamètres d'un module IA.""" return f"Paramètre {param} de {module} ajusté à {valeur} (simulation)" def ia_vision(self, action, image): """Analyse d'images avancée.""" return f"Vision IA {action} sur {image} (simulation)" def ia_nlp(self, action, texte): """Analyse sémantique, résumé, extraction d'entités, etc.""" return f"NLP IA {action} sur '{texte}' (simulation)" def ia_voice(self, action, audio): """Analyse, synthèse, reconnaissance vocale avancée.""" return f"Voice IA {action} sur {audio} (simulation)" # --- Interactions multi-modules avancées --- def scenario(self, modules, description): """Création et exécution de scénarios complexes multi-modules.""" return f"Scénario exécuté sur [{modules}] : {description} (simulation)" def monitoring(self, modules, periode): """Surveillance continue et reporting croisé de modules.""" return f"Monitoring de [{modules}] sur {periode} (simulation)" def optimisation(self, objectif, modules): """Optimisation multi-critères sur plusieurs modules.""" return f"Optimisation de {objectif} sur [{modules}] (simulation)" def fusiondata(self, sources, objectif): """Fusion intelligente de données issues de plusieurs modules.""" return f"Fusion de {sources} pour {objectif} (simulation)" def eventtrigger(self, condition, actions): """Déclenchement d'actions croisées sur événement complexe.""" return f"EventTrigger : si {condition} alors {actions} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("sleep_cancel"): return self.sleep_cancel() if entree.lower().startswith("sleep_etat"): return self.sleep_etat() if entree.lower().startswith("time "): fuseau = entree[5:] return self.time_now(fuseau) if entree.lower().startswith("time_since "): event_time = entree[10:] return self.time_since(event_time) if entree.lower().startswith("minuteur "): secondes = entree[9:] return self.minuteur(secondes) if entree.lower().startswith("minuteur_cancel"): return self.minuteur_cancel() if entree.lower().startswith("minuteur_etat"): return self.minuteur_etat() if entree.lower().startswith("genomique "): parts = entree.split() action = parts[1] sequence = parts[2] info = parts[3] if len(parts)>3 else None return self.genomique(action, sequence, info) if entree.lower().startswith("climatologie "): parts = entree.split() action = parts[1] lieu = parts[2] param = parts[3] if len(parts)>3 else None return self.climatologie(action, lieu, param) if entree.lower().startswith("nanotech "): parts = entree.split() action = parts[1] materiau = parts[2] operation = parts[3] if len(parts)>3 else None return self.nanotech(action, materiau, operation) if entree.lower().startswith("cyberdefense "): parts = entree.split() action = parts[1] cible = parts[2] type_ = parts[3] if len(parts)>3 else None return self.cyberdefense(action, cible, type_) if entree.lower().startswith("exobio "): parts = entree.split() action = parts[1] planete = parts[2] param = parts[3] if len(parts)>3 else None return self.exobio(action, planete, param) if entree.lower().startswith("ia_explain "): parts = entree.split() module = parts[1] requete = " ".join(parts[2:]) return self.ia_explain(module, requete) if entree.lower().startswith("ia_autotune "): parts = entree.split() module = parts[1] param = parts[2] valeur = parts[3] if len(parts)>3 else None return self.ia_autotune(module, param, valeur) if entree.lower().startswith("ia_vision "): parts = entree.split() action = parts[1] image = parts[2] return self.ia_vision(action, image) if entree.lower().startswith("ia_nlp "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.ia_nlp(action, texte) if entree.lower().startswith("ia_voice "): parts = entree.split() action = parts[1] audio = parts[2] return self.ia_voice(action, audio) if entree.lower().startswith("scenario "): parts = entree.split() modules = parts[1] description = " ".join(parts[2:]) return self.scenario(modules, description) if entree.lower().startswith("monitoring "): parts = entree.split() modules = parts[1] periode = parts[2] if len(parts)>2 else None return self.monitoring(modules, periode) if entree.lower().startswith("optimisation "): parts = entree.split() objectif = parts[1] modules = " ".join(parts[2:]) return self.optimisation(objectif, modules) if entree.lower().startswith("fusiondata "): parts = entree.split() sources = parts[1] objectif = " ".join(parts[2:]) return self.fusiondata(sources, objectif) if entree.lower().startswith("eventtrigger "): parts = entree.split() condition = parts[1] actions = " ".join(parts[2:]) return self.eventtrigger(condition, actions) # ... reste du cycle inchangé ... # --- Modules généralistes enrichis --- def agenda(self, action, date, objet=None): if not hasattr(self, 'agendas'): self.agendas = {} if action == 'ajout' and objet: self.agendas.setdefault(date, []).append(objet) return f"Événement '{objet}' ajouté à l'agenda du {date}." elif action == 'liste': return str(self.agendas.get(date, [])) elif action == 'supprime' and objet: if date in self.agendas and objet in self.agendas[date]: self.agendas[date].remove(objet) return f"Événement '{objet}' supprimé du {date}." return f"Événement non trouvé." return "Action agenda inconnue." def note(self, action, texte): if not hasattr(self, 'notes'): self.notes = [] if action == 'ajout': self.notes.append(texte) return f"Note ajoutée : {texte}" elif action == 'liste': return '\n'.join(self.notes) elif action == 'supprime': if texte in self.notes: self.notes.remove(texte) return f"Note supprimée : {texte}" return "Note non trouvée." return "Action note inconnue." def rappel(self, action, texte): if not hasattr(self, 'rappels'): self.rappels = [] if action == 'ajout': self.rappels.append(texte) return f"Rappel ajouté : {texte}" elif action == 'liste': return '\n'.join(self.rappels) elif action == 'supprime': if texte in self.rappels: self.rappels.remove(texte) return f"Rappel supprimé : {texte}" return "Rappel non trouvé." return "Action rappel inconnue." def calcul(self, expression): try: result = eval(expression, {"__builtins__": None, "math": math}, {}) return f"Résultat : {result}" except Exception as e: return f"Erreur de calcul : {e}" def convert(self, valeur, unite_source, unite_cible): conversions = {('m','km'): lambda x: x/1000, ('km','m'): lambda x: x*1000, ('kg','g'): lambda x: x*1000, ('g','kg'): lambda x: x/1000} try: valeur = float(valeur) f = conversions.get((unite_source, unite_cible)) if f: return f"{valeur} {unite_source} = {f(valeur)} {unite_cible}" return "Conversion non supportée." except Exception as e: return f"Erreur de conversion : {e}" def web(self, requete): return f"Recherche web simulée pour : {requete}" def traduire(self, texte, langue): return f"Traduction simulée de '{texte}' en {langue}" def favori(self, action, url): if not hasattr(self, 'favoris'): self.favoris = [] if action == 'ajout': self.favoris.append(url) return f"Favori ajouté : {url}" elif action == 'liste': return '\n'.join(self.favoris) elif action == 'supprime': if url in self.favoris: self.favoris.remove(url) return f"Favori supprimé : {url}" return "Favori non trouvé." return "Action favori inconnue." def fichier(self, action, nom): if action == 'creer': with open(nom, 'w') as f: f.write('') return f"Fichier {nom} créé." elif action == 'lire': try: with open(nom, 'r') as f: return f.read() except: return "Fichier introuvable." elif action == 'supprime': import os try: os.remove(nom) return f"Fichier {nom} supprimé." except: return "Fichier introuvable." elif action == 'liste': import os return ', '.join(os.listdir('.')) return "Action fichier inconnue." def contact(self, action, nom): if not hasattr(self, 'contacts'): self.contacts = [] if action == 'ajout': self.contacts.append(nom) return f"Contact ajouté : {nom}" elif action == 'liste': return '\n'.join(self.contacts) elif action == 'supprime': if nom in self.contacts: self.contacts.remove(nom) return f"Contact supprimé : {nom}" return "Contact non trouvé." return "Action contact inconnue." def liste(self, action, nom, item=None): if not hasattr(self, 'listes'): self.listes = {} if action == 'creer': self.listes[nom] = [] return f"Liste {nom} créée." elif action == 'ajout' and item: self.listes.setdefault(nom, []).append(item) return f"{item} ajouté à la liste {nom}." elif action == 'supprime' and item: if nom in self.listes and item in self.listes[nom]: self.listes[nom].remove(item) return f"{item} supprimé de la liste {nom}." return "Item non trouvé." elif action == 'liste': return ', '.join(self.listes.get(nom, [])) return "Action liste inconnue." def depense(self, action, montant, objet=None): if not hasattr(self, 'depenses'): self.depenses = [] if action == 'ajout' and objet: self.depenses.append((float(montant), objet)) return f"Dépense ajoutée : {montant}€ pour {objet}" elif action == 'liste': return '\n'.join([f"{m}€ - {o}" for m,o in self.depenses]) elif action == 'supprime' and objet: self.depenses = [d for d in self.depenses if d[1]!=objet] return f"Dépense pour {objet} supprimée." return "Action depense inconnue." def recette(self, action, plat): if not hasattr(self, 'recettes'): self.recettes = [] if action == 'ajout': self.recettes.append(plat) return f"Recette ajoutée : {plat}" elif action == 'liste': return '\n'.join(self.recettes) elif action == 'supprime': if plat in self.recettes: self.recettes.remove(plat) return f"Recette supprimée : {plat}" return "Recette non trouvée." return "Action recette inconnue." def projet(self, action, nom): if not hasattr(self, 'projets'): self.projets = [] if action == 'ajout': self.projets.append(nom) return f"Projet ajouté : {nom}" elif action == 'liste': return '\n'.join(self.projets) elif action == 'supprime': if nom in self.projets: self.projets.remove(nom) return f"Projet supprimé : {nom}" return "Projet non trouvé." return "Action projet inconnue." def tache(self, action, nom): if not hasattr(self, 'taches'): self.taches = [] if action == 'ajout': self.taches.append(nom) return f"Tâche ajoutée : {nom}" elif action == 'liste': return '\n'.join(self.taches) elif action == 'supprime': if nom in self.taches: self.taches.remove(nom) return f"Tâche supprimée : {nom}" return "Tâche non trouvée." return "Action tache inconnue." def meteo(self, ville): return f"Météo simulée pour {ville} : {random.choice(['Soleil','Pluie','Nuageux','Orage'])}" def transport(self, action, trajet): if not hasattr(self, 'transports'): self.transports = [] if action == 'ajout': self.transports.append(trajet) return f"Trajet ajouté : {trajet}" elif action == 'liste': return '\n'.join(self.transports) elif action == 'supprime': if trajet in self.transports: self.transports.remove(trajet) return f"Trajet supprimé : {trajet}" return "Trajet non trouvé." return "Action transport inconnue." def musique(self, action, titre): if not hasattr(self, 'musiques'): self.musiques = [] if action == 'ajout': self.musiques.append(titre) return f"Morceau ajouté : {titre}" elif action == 'liste': return '\n'.join(self.musiques) elif action == 'supprime': if titre in self.musiques: self.musiques.remove(titre) return f"Morceau supprimé : {titre}" return "Morceau non trouvé." return "Action musique inconnue." def film(self, action, titre): if not hasattr(self, 'films'): self.films = [] if action == 'ajout': self.films.append(titre) return f"Film ajouté : {titre}" elif action == 'liste': return '\n'.join(self.films) elif action == 'supprime': if titre in self.films: self.films.remove(titre) return f"Film supprimé : {titre}" return "Film non trouvé." return "Action film inconnue." def livre(self, action, titre): if not hasattr(self, 'livres'): self.livres = [] if action == 'ajout': self.livres.append(titre) return f"Livre ajouté : {titre}" elif action == 'liste': return '\n'.join(self.livres) elif action == 'supprime': if titre in self.livres: self.livres.remove(titre) return f"Livre supprimé : {titre}" return "Livre non trouvé." return "Action livre inconnue." # --- Modules spécialisés --- def sentiment(self, texte): return f"Analyse de sentiment simulée : {random.choice(['positif','négatif','neutre'])} pour '{texte}'" def image(self, action, fichier): return f"Image {action} sur {fichier} (simulation)" def tts(self, texte): return f"Synthèse vocale simulée pour : {texte}" def stt(self, fichier): return f"Reconnaissance vocale simulée sur {fichier}" def codegen(self, langage, tache): return f"Code généré en {langage} pour : {tache} (simulation)" def reunion(self, action, sujet): return f"Réunion {action} sur {sujet} (simulation)" def cv(self, action, nom): return f"CV {action} pour {nom} (simulation)" def portfolio(self, action, projet): return f"Portfolio {action} pour {projet} (simulation)" def newsletter(self, action, sujet): return f"Newsletter {action} sur {sujet} (simulation)" def chatbotsim(self, mode, message): return f"Chatbot simulé ({mode}) : {message}" # --- Modules spécialisés enrichis --- def calpartage(self, action, groupe, date, evenement=None): if not hasattr(self, 'calendriers_partages'): self.calendriers_partages = {} key = (groupe, date) if action == 'ajout' and evenement: self.calendriers_partages.setdefault(key, []).append(evenement) return f"Événement '{evenement}' ajouté au calendrier du groupe {groupe} pour le {date}." elif action == 'liste': return str(self.calendriers_partages.get(key, [])) elif action == 'supprime' and evenement: if key in self.calendriers_partages and evenement in self.calendriers_partages[key]: self.calendriers_partages[key].remove(evenement) return f"Événement '{evenement}' supprimé du calendrier du groupe {groupe} pour le {date}." return "Événement non trouvé." return "Action calpartage inconnue." def budgetfamille(self, action, membre, montant=None, objet=None): if not hasattr(self, 'budgets_famille'): self.budgets_famille = {} if action == 'ajout' and montant and objet: self.budgets_famille.setdefault(membre, []).append((float(montant), objet)) return f"Dépense de {montant}€ pour {objet} ajoutée à {membre}." elif action == 'liste': return str(self.budgets_famille.get(membre, [])) elif action == 'bilan': total = sum([m for m, _ in self.budgets_famille.get(membre, [])]) return f"Total dépensé par {membre} : {total}€" return "Action budgetfamille inconnue." def santeperso(self, action, parametre, valeur=None): if not hasattr(self, 'sante_perso'): self.sante_perso = {} if action == 'ajout' and valeur: self.sante_perso.setdefault(parametre, []).append(valeur) return f"{parametre} enregistré : {valeur}" elif action == 'historique': return str(self.sante_perso.get(parametre, [])) elif action == 'stat': vals = [float(v) for v in self.sante_perso.get(parametre, []) if self._is_number(v)] if vals: return f"Moyenne de {parametre} : {sum(vals)/len(vals):.2f}" return "Pas de données." return "Action santeperso inconnue." def _is_number(self, s): try: float(s); return True except: return False def bienetre(self, action, routine): if not hasattr(self, 'routines_bienetre'): self.routines_bienetre = [] if action == 'ajout': self.routines_bienetre.append(routine) return f"Routine bien-être ajoutée : {routine}" elif action == 'liste': return '\n'.join(self.routines_bienetre) return "Action bienetre inconnue." def shopping(self, action, item): if not hasattr(self, 'shopping_list'): self.shopping_list = [] if action == 'ajout': self.shopping_list.append(item) return f"Article ajouté à la liste de shopping : {item}" elif action == 'suggestion': return f"Suggestion d'achat : {random.choice(self.shopping_list) if self.shopping_list else 'Aucune'}" elif action == 'liste': return ', '.join(self.shopping_list) return "Action shopping inconnue." def notifcontext(self, action, message): return f"Notification contextuelle ({action}) : {message}" def voyagesim(self, action, destination): if not hasattr(self, 'voyages'): self.voyages = [] if action == 'planifier': self.voyages.append(destination) return f"Voyage planifié vers {destination}" elif action == 'liste': return ', '.join(self.voyages) return "Action voyagesim inconnue." def carrieresim(self, action, poste): if not hasattr(self, 'carrieres'): self.carrieres = [] if action == 'ajout': self.carrieres.append(poste) return f"Poste ajouté à la carrière simulée : {poste}" elif action == 'liste': return ', '.join(self.carrieres) return "Action carrieresim inconnue." def maisonco(self, action, appareil): if not hasattr(self, 'maison_connectee'): self.maison_connectee = [] if action == 'ajout': self.maison_connectee.append(appareil) return f"Appareil connecté ajouté : {appareil}" elif action == 'liste': return ', '.join(self.maison_connectee) return "Action maisonco inconnue." def amisim(self, action, nom): if not hasattr(self, 'amis'): self.amis = [] if action == 'ajout': self.amis.append(nom) return f"Ami ajouté : {nom}" elif action == 'liste': return ', '.join(self.amis) return "Action amisim inconnue." def forumsim(self, action, sujet): if not hasattr(self, 'forums'): self.forums = [] if action == 'creer': self.forums.append(sujet) return f"Forum créé sur : {sujet}" elif action == 'liste': return ', '.join(self.forums) return "Action forumsim inconnue." def clubsport(self, action, discipline): if not hasattr(self, 'clubs_sport'): self.clubs_sport = [] if action == 'ajout': self.clubs_sport.append(discipline) return f"Discipline ajoutée au club sportif : {discipline}" elif action == 'liste': return ', '.join(self.clubs_sport) return "Action clubsport inconnue." def bibliox(self, action, livre): if not hasattr(self, 'bibliox_livres'): self.bibliox_livres = [] if action == 'ajout': self.bibliox_livres.append(livre) return f"Livre ajouté à la bibliothèque partagée : {livre}" elif action == 'liste': return ', '.join(self.bibliox_livres) return "Action bibliox inconnue." def potager(self, action, plante): if not hasattr(self, 'potager_plantes'): self.potager_plantes = [] if action == 'planter': self.potager_plantes.append(plante) return f"Plante ajoutée au potager : {plante}" elif action == 'liste': return ', '.join(self.potager_plantes) elif action == 'conseil': return f"Conseil pour {plante} : Arroser régulièrement et surveiller la météo." return "Action potager inconnue." def brainstormx(self, action, theme): if not hasattr(self, 'brainstorm_sessions'): self.brainstorm_sessions = [] if action == 'creer': self.brainstorm_sessions.append(theme) return f"Session de brainstorming créée sur : {theme}" elif action == 'liste': return ', '.join(self.brainstorm_sessions) return "Action brainstormx inconnue." # --- Modules supplémentaires spécialisés --- def finance(self, action, compte, montant=None): if not hasattr(self, 'finances'): self.finances = {} if action == 'ajout' and montant: self.finances.setdefault(compte, 0) self.finances[compte] += float(montant) return f"{montant}€ ajouté au compte {compte}." elif action == 'solde': return f"Solde du compte {compte} : {self.finances.get(compte,0)}€" return "Action finance inconnue." def education(self, action, matiere, note=None): if not hasattr(self, 'notes_education'): self.notes_education = {} if action == 'ajout' and note: self.notes_education.setdefault(matiere, []).append(float(note)) return f"Note {note} ajoutée en {matiere}." elif action == 'moyenne': notes = self.notes_education.get(matiere,[]) if notes: return f"Moyenne en {matiere} : {sum(notes)/len(notes):.2f}" return "Aucune note." return "Action education inconnue." def science(self, action, experience): if not hasattr(self, 'experiences_science'): self.experiences_science = [] if action == 'ajout': self.experiences_science.append(experience) return f"Expérience scientifique ajoutée : {experience}" elif action == 'liste': return ', '.join(self.experiences_science) return "Action science inconnue." def document(self, action, nom): if not hasattr(self, 'documents'): self.documents = [] if action == 'ajout': self.documents.append(nom) return f"Document ajouté : {nom}" elif action == 'liste': return ', '.join(self.documents) return "Action document inconnue." def support(self, action, ticket): if not hasattr(self, 'tickets_support'): self.tickets_support = [] if action == 'ajout': self.tickets_support.append(ticket) return f"Ticket de support ajouté : {ticket}" elif action == 'liste': return ', '.join(self.tickets_support) return "Action support inconnue." def codecollab(self, action, repo): if not hasattr(self, 'repos_collab'): self.repos_collab = [] if action == 'ajout': self.repos_collab.append(repo) return f"Repo collaboratif ajouté : {repo}" elif action == 'liste': return ', '.join(self.repos_collab) return "Action codecollab inconnue." def podcastx(self, action, episode): if not hasattr(self, 'podcast_episodes'): self.podcast_episodes = [] if action == 'ajout': self.podcast_episodes.append(episode) return f"Épisode de podcast ajouté : {episode}" elif action == 'liste': return ', '.join(self.podcast_episodes) return "Action podcastx inconnue." def recettesante(self, action, plat): if not hasattr(self, 'recettes_sante'): self.recettes_sante = [] if action == 'ajout': self.recettes_sante.append(plat) return f"Recette santé ajoutée : {plat}" elif action == 'liste': return ', '.join(self.recettes_sante) return "Action recettesante inconnue." def quizperso(self, action, theme): if not hasattr(self, 'quiz_perso'): self.quiz_perso = [] if action == 'creer': self.quiz_perso.append(theme) return f"Quiz personnalisé créé sur : {theme}" elif action == 'liste': return ', '.join(self.quiz_perso) return "Action quizperso inconnue." def societesim(self, action, evenement): if not hasattr(self, 'societesim_events'): self.societesim_events = [] if action == 'ajout': self.societesim_events.append(evenement) return f"Événement ajouté à la simulation de société : {evenement}" elif action == 'liste': return ', '.join(self.societesim_events) return "Action societesim inconnue." # --- Modules ultra-spécialisés --- def bioinfo(self, action, gene, valeur=None): """Analyse et gestion de données biologiques/génomiques.""" if not hasattr(self, 'bioinfo_data'): self.bioinfo_data = {} if action == 'ajout' and valeur: self.bioinfo_data[gene] = valeur return f"Gène {gene} enregistré avec valeur {valeur}." elif action == 'analyse': return f"Analyse du gène {gene} : {self.bioinfo_data.get(gene, 'inconnu')}" return "Action bioinfo inconnue." def astro(self, action, objet, valeur=None): """Observation, simulation et gestion d'objets astronomiques.""" if not hasattr(self, 'astro_data'): self.astro_data = {} if action == 'ajout' and valeur: self.astro_data[objet] = valeur return f"Objet {objet} enregistré avec valeur {valeur}." elif action == 'observe': return f"Observation de {objet} : {self.astro_data.get(objet, 'inconnu')}" return "Action astro inconnue." def robotique(self, action, robot, tache=None): """Contrôle, simulation et historique de robots.""" if not hasattr(self, 'robotique_taches'): self.robotique_taches = {} if action == 'ajout' and tache: self.robotique_taches.setdefault(robot, []).append(tache) return f"Tâche '{tache}' ajoutée au robot {robot}." elif action == 'liste': return ', '.join(self.robotique_taches.get(robot, [])) return "Action robotique inconnue." def quantique(self, action, exp, param=None): """Simulation d'expériences quantiques.""" if not hasattr(self, 'quantique_exp'): self.quantique_exp = {} if action == 'ajout' and param: self.quantique_exp[exp] = param return f"Expérience {exp} enregistrée avec paramètre {param}." elif action == 'simule': return f"Simulation de {exp} : {self.quantique_exp.get(exp, 'inconnu')}" return "Action quantique inconnue." def holo(self, action, scene, param=None): """Gestion et simulation d'environnements holographiques.""" if not hasattr(self, 'holo_scenes'): self.holo_scenes = {} if action == 'ajout' and param: self.holo_scenes[scene] = param return f"Scène holographique {scene} ajoutée avec paramètre {param}." elif action == 'affiche': return f"Affichage de la scène {scene} : {self.holo_scenes.get(scene, 'inconnue')}" return "Action holo inconnue." def droneessaim(self, action, mission, nb=None): """Contrôle d'essaims de drones.""" if not hasattr(self, 'droneessaim_missions'): self.droneessaim_missions = [] if action == 'ajout' and nb: self.droneessaim_missions.append((mission, nb)) return f"Mission '{mission}' assignée à un essaim de {nb} drones." elif action == 'liste': return ', '.join([f"{m} ({n} drones)" for m, n in self.droneessaim_missions]) return "Action droneessaim inconnue." def cryptoanalyse(self, action, algo, texte=None): """Analyse et simulation de cryptographie avancée.""" if not hasattr(self, 'cryptoanalyse_data'): self.cryptoanalyse_data = {} if action == 'chiffre' and texte: res = f"{texte[::-1]} (simulé)" self.cryptoanalyse_data[algo] = res return f"Texte chiffré avec {algo} : {res}" elif action == 'dechiffre': return f"Texte déchiffré : {self.cryptoanalyse_data.get(algo, 'inconnu')}" return "Action cryptoanalyse inconnue." def neuro(self, action, patient, signal=None): """Analyse de signaux neuronaux, simulation d'interface cerveau-machine.""" if not hasattr(self, 'neuro_signaux'): self.neuro_signaux = {} if action == 'ajout' and signal: self.neuro_signaux.setdefault(patient, []).append(signal) return f"Signal '{signal}' ajouté pour {patient}." elif action == 'analyse': return f"Signaux de {patient} : {self.neuro_signaux.get(patient, [])}" return "Action neuro inconnue." def swarmia(self, action, tache, nb_agents=None): """Simulation de comportements collectifs multi-agents.""" if not hasattr(self, 'swarmia_taches'): self.swarmia_taches = [] if action == 'ajout' and nb_agents: self.swarmia_taches.append((tache, nb_agents)) return f"Tâche '{tache}' assignée à {nb_agents} agents." elif action == 'liste': return ', '.join([f"{t} ({n} agents)" for t, n in self.swarmia_taches]) return "Action swarmia inconnue." def biotech(self, action, protocole, param=None): """Gestion de protocoles biotechnologiques.""" if not hasattr(self, 'biotech_protocoles'): self.biotech_protocoles = {} if action == 'ajout' and param: self.biotech_protocoles[protocole] = param return f"Protocole {protocole} ajouté avec paramètre {param}." elif action == 'liste': return ', '.join(self.biotech_protocoles.keys()) return "Action biotech inconnue." # --- Extensions IA --- def ia_train(self, module, donnees): """Entraîne un sous-module IA sur des données fournies (simulation).""" return f"Module {module} entraîné sur données : {donnees} (simulation)" def ia_eval(self, module, tache): """Évalue la performance d'un module IA (simulation).""" return f"Évaluation de {module} sur tâche {tache} : score 0.98 (simulation)" def ia_autoameliore(self, module, objectif): """Propose et applique des améliorations à un module IA (simulation).""" return f"Module {module} auto-amélioré pour objectif : {objectif} (simulation)" def ia_multiagent(self, action, nb_agents, tache): """Simule collaboration/compétition entre plusieurs IA internes.""" return f"{nb_agents} IA internes {action} la tâche : {tache} (simulation)" def ia_persona(self, action, profil): """Crée, modifie, active des personnalités IA spécialisées.""" return f"Personnalité IA {action} : {profil} (simulation)" # --- Interactions multi-modules --- def workflow(self, modules, tache): """Orchestre plusieurs modules pour accomplir une tâche complexe.""" return f"Workflow lancé sur modules [{modules}] pour tâche : {tache} (simulation)" def datapipeline(self, sources, traitements, destination): """Crée un pipeline de données entre modules.""" return f"Pipeline de {sources} via {traitements} vers {destination} (simulation)" def alertesmart(self, modules, condition, action): """Déclenche des actions croisées selon conditions sur plusieurs modules.""" return f"Alerte intelligente sur [{modules}] si {condition} alors {action} (simulation)" def rapportglobal(self, modules): """Génère un rapport croisé sur plusieurs modules.""" return f"Rapport global généré pour modules : {modules} (simulation)" def planificationia(self, objectif): """Planifie et répartit des tâches sur plusieurs modules.""" return f"Planification IA pour objectif : {objectif} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("agenda "): parts = entree.split() action = parts[1] date = parts[2] objet = " ".join(parts[3:]) if len(parts)>3 else None return self.agenda(action, date, objet) if entree.lower().startswith("note "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.note(action, texte) if entree.lower().startswith("rappel "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.rappel(action, texte) if entree.lower().startswith("calcul "): expression = entree[7:] return self.calcul(expression) if entree.lower().startswith("convert "): parts = entree.split() valeur = parts[1] unite_source = parts[2] unite_cible = parts[3] return self.convert(valeur, unite_source, unite_cible) if entree.lower().startswith("web "): requete = entree[4:] return self.web(requete) if entree.lower().startswith("traduire "): parts = entree.split() texte = parts[1] langue = parts[2] if len(parts)>2 else 'en' return self.traduire(texte, langue) if entree.lower().startswith("favori "): parts = entree.split() action = parts[1] url = parts[2] return self.favori(action, url) if entree.lower().startswith("fichier "): parts = entree.split() action = parts[1] nom = parts[2] return self.fichier(action, nom) if entree.lower().startswith("contact "): parts = entree.split() action = parts[1] nom = parts[2] return self.contact(action, nom) if entree.lower().startswith("liste "): parts = entree.split() action = parts[1] nom = parts[2] item = " ".join(parts[3:]) if len(parts)>3 else None return self.liste(action, nom, item) if entree.lower().startswith("depense "): parts = entree.split() action = parts[1] montant = parts[2] objet = " ".join(parts[3:]) if len(parts)>3 else None return self.depense(action, montant, objet) if entree.lower().startswith("recette "): parts = entree.split() action = parts[1] plat = " ".join(parts[2:]) return self.recette(action, plat) if entree.lower().startswith("projet "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.projet(action, nom) if entree.lower().startswith("tache "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.tache(action, nom) if entree.lower().startswith("meteo "): ville = entree[6:] return self.meteo(ville) if entree.lower().startswith("transport "): parts = entree.split() action = parts[1] trajet = " ".join(parts[2:]) return self.transport(action, trajet) if entree.lower().startswith("musique "): parts = entree.split() action = parts[1] titre = " ".join(parts[2:]) return self.musique(action, titre) if entree.lower().startswith("film "): parts = entree.split() action = parts[1] titre = " ".join(parts[2:]) return self.film(action, titre) if entree.lower().startswith("livre "): parts = entree.split() action = parts[1] titre = " ".join(parts[2:]) return self.livre(action, titre) # --- Modules spécialisés --- if entree.lower().startswith("sentiment "): texte = entree[10:] return self.sentiment(texte) if entree.lower().startswith("image "): parts = entree.split() action = parts[1] fichier = parts[2] return self.image(action, fichier) if entree.lower().startswith("tts "): texte = entree[4:] return self.tts(texte) if entree.lower().startswith("stt "): fichier = entree[4:] return self.stt(fichier) if entree.lower().startswith("codegen "): parts = entree.split() langage = parts[1] tache = " ".join(parts[2:]) return self.codegen(langage, tache) if entree.lower().startswith("reunion "): parts = entree.split() action = parts[1] sujet = " ".join(parts[2:]) return self.reunion(action, sujet) if entree.lower().startswith("cv "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.cv(action, nom) if entree.lower().startswith("portfolio "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.portfolio(action, projet) if entree.lower().startswith("newsletter "): parts = entree.split() action = parts[1] sujet = " ".join(parts[2:]) return self.newsletter(action, sujet) if entree.lower().startswith("chatbotsim "): parts = entree.split() mode = parts[1] message = " ".join(parts[2:]) return self.chatbotsim(mode, message) # ... reste du cycle inchangé ... # --- Modules spécialisés enrichis --- def domotique(self, action, appareil, valeur=None): """Gère les appareils domotiques (ajout, état, commande, historique).""" if not hasattr(self, 'domotique_etat'): self.domotique_etat = {} if action == 'ajout': self.domotique_etat[appareil] = valeur or 'off' return f"Appareil {appareil} ajouté avec état {self.domotique_etat[appareil]}." elif action == 'etat': return f"État de {appareil} : {self.domotique_etat.get(appareil, 'inconnu')}" elif action == 'commande' and valeur: if appareil in self.domotique_etat: self.domotique_etat[appareil] = valeur return f"{appareil} réglé sur {valeur}." return "Appareil inconnu." elif action == 'historique': return str(self.domotique_etat) return "Action domotique inconnue." def urbansim(self, action, quartier, evenement=None): """Simule des événements urbains (ajout, liste, statistiques).""" if not hasattr(self, 'urbansim_events'): self.urbansim_events = {} if action == 'ajout' and evenement: self.urbansim_events.setdefault(quartier, []).append(evenement) return f"Événement '{evenement}' ajouté au quartier {quartier}." elif action == 'liste': return str(self.urbansim_events.get(quartier, [])) elif action == 'stats': return f"Nombre d'événements dans {quartier} : {len(self.urbansim_events.get(quartier, []))}" return "Action urbansim inconnue." def equipe(self, action, membre, role=None): """Gère une équipe (ajout, rôle, liste, historique).""" if not hasattr(self, 'equipe_membres'): self.equipe_membres = {} if action == 'ajout' and role: self.equipe_membres[membre] = role return f"Membre {membre} ajouté avec rôle {role}." elif action == 'liste': return ', '.join([f"{m} ({r})" for m, r in self.equipe_membres.items()]) elif action == 'role': return f"Rôle de {membre} : {self.equipe_membres.get(membre, 'inconnu')}" return "Action equipe inconnue." def agile(self, action, projet, tache=None): """Gère des projets agiles (ajout, taches, stats, historique).""" if not hasattr(self, 'agile_projets'): self.agile_projets = {} if action == 'ajout' and tache: self.agile_projets.setdefault(projet, []).append(tache) return f"Tâche '{tache}' ajoutée au projet {projet}." elif action == 'liste': return str(self.agile_projets.get(projet, [])) elif action == 'stats': return f"Nombre de tâches dans {projet} : {len(self.agile_projets.get(projet, []))}" return "Action agile inconnue." def blockchain(self, action, transaction): """Gère des transactions blockchain (ajout, historique, stats).""" if not hasattr(self, 'blockchain_tx'): self.blockchain_tx = [] if action == 'ajout': self.blockchain_tx.append(transaction) return f"Transaction ajoutée : {transaction}" elif action == 'historique': return '\n'.join(self.blockchain_tx) elif action == 'stats': return f"Nombre de transactions : {len(self.blockchain_tx)}" return "Action blockchain inconnue." def drone(self, action, mission): """Gère des missions de drones (ajout, liste, stats).""" if not hasattr(self, 'drone_missions'): self.drone_missions = [] if action == 'ajout': self.drone_missions.append(mission) return f"Mission de drone ajoutée : {mission}" elif action == 'liste': return ', '.join(self.drone_missions) elif action == 'stats': return f"Nombre de missions : {len(self.drone_missions)}" return "Action drone inconnue." def energie(self, action, source, valeur=None): """Gère les ressources énergétiques (ajout, stats, historique).""" if not hasattr(self, 'energie_sources'): self.energie_sources = {} if action == 'ajout' and valeur: self.energie_sources.setdefault(source, []).append(float(valeur)) return f"{valeur} unités ajoutées à {source}." elif action == 'stats': total = sum(self.energie_sources.get(source, [])) return f"Total énergie {source} : {total}" elif action == 'historique': return str(self.energie_sources.get(source, [])) return "Action energie inconnue." def securitephy(self, action, zone, incident=None): """Gère la sécurité physique (ajout, incidents, stats).""" if not hasattr(self, 'securitephy_incidents'): self.securitephy_incidents = {} if action == 'ajout' and incident: self.securitephy_incidents.setdefault(zone, []).append(incident) return f"Incident '{incident}' ajouté à la zone {zone}." elif action == 'liste': return str(self.securitephy_incidents.get(zone, [])) elif action == 'stats': return f"Nombre d'incidents dans {zone} : {len(self.securitephy_incidents.get(zone, []))}" return "Action securitephy inconnue." def mobilite(self, action, vehicule, trajet=None): """Gère la mobilité intelligente (ajout, trajets, stats).""" if not hasattr(self, 'mobilite_trajets'): self.mobilite_trajets = {} if action == 'ajout' and trajet: self.mobilite_trajets.setdefault(vehicule, []).append(trajet) return f"Trajet '{trajet}' ajouté au véhicule {vehicule}." elif action == 'liste': return str(self.mobilite_trajets.get(vehicule, [])) elif action == 'stats': return f"Nombre de trajets pour {vehicule} : {len(self.mobilite_trajets.get(vehicule, []))}" return "Action mobilite inconnue." def criseworld(self, action, scenario): """Simule des crises globales (ajout, historique, stats).""" if not hasattr(self, 'criseworld_scenarios'): self.criseworld_scenarios = [] if action == 'ajout': self.criseworld_scenarios.append(scenario) return f"Scénario de crise ajouté : {scenario}" elif action == 'historique': return '\n'.join(self.criseworld_scenarios) elif action == 'stats': return f"Nombre de scénarios : {len(self.criseworld_scenarios)}" return "Action criseworld inconnue." # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("domotique "): parts = entree.split() action = parts[1] appareil = parts[2] valeur = parts[3] if len(parts)>3 else None return self.domotique(action, appareil, valeur) if entree.lower().startswith("urbansim "): parts = entree.split() action = parts[1] quartier = parts[2] evenement = " ".join(parts[3:]) if len(parts)>3 else None return self.urbansim(action, quartier, evenement) if entree.lower().startswith("equipe "): parts = entree.split() action = parts[1] membre = parts[2] role = parts[3] if len(parts)>3 else None return self.equipe(action, membre, role) if entree.lower().startswith("agile "): parts = entree.split() action = parts[1] projet = parts[2] tache = " ".join(parts[3:]) if len(parts)>3 else None return self.agile(action, projet, tache) if entree.lower().startswith("blockchain "): parts = entree.split() action = parts[1] transaction = " ".join(parts[2:]) return self.blockchain(action, transaction) if entree.lower().startswith("drone "): parts = entree.split() action = parts[1] mission = " ".join(parts[2:]) return self.drone(action, mission) if entree.lower().startswith("energie "): parts = entree.split() action = parts[1] source = parts[2] valeur = parts[3] if len(parts)>3 else None return self.energie(action, source, valeur) if entree.lower().startswith("securitephy "): parts = entree.split() action = parts[1] zone = parts[2] incident = " ".join(parts[3:]) if len(parts)>3 else None return self.securitephy(action, zone, incident) if entree.lower().startswith("mobilite "): parts = entree.split() action = parts[1] vehicule = parts[2] trajet = " ".join(parts[3:]) if len(parts)>3 else None return self.mobilite(action, vehicule, trajet) if entree.lower().startswith("criseworld "): parts = entree.split() action = parts[1] scenario = " ".join(parts[2:]) return self.criseworld(action, scenario) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés --- def bioinfo(self, action, gene, valeur=None): """Analyse et gestion de données biologiques/génomiques.""" if not hasattr(self, 'bioinfo_data'): self.bioinfo_data = {} if action == 'ajout' and valeur: self.bioinfo_data[gene] = valeur return f"Gène {gene} enregistré avec valeur {valeur}." elif action == 'analyse': return f"Analyse du gène {gene} : {self.bioinfo_data.get(gene, 'inconnu')}" return "Action bioinfo inconnue." def astro(self, action, objet, valeur=None): """Observation, simulation et gestion d'objets astronomiques.""" if not hasattr(self, 'astro_data'): self.astro_data = {} if action == 'ajout' and valeur: self.astro_data[objet] = valeur return f"Objet {objet} enregistré avec valeur {valeur}." elif action == 'observe': return f"Observation de {objet} : {self.astro_data.get(objet, 'inconnu')}" return "Action astro inconnue." def robotique(self, action, robot, tache=None): """Contrôle, simulation et historique de robots.""" if not hasattr(self, 'robotique_taches'): self.robotique_taches = {} if action == 'ajout' and tache: self.robotique_taches.setdefault(robot, []).append(tache) return f"Tâche '{tache}' ajoutée au robot {robot}." elif action == 'liste': return ', '.join(self.robotique_taches.get(robot, [])) return "Action robotique inconnue." def quantique(self, action, exp, param=None): """Simulation d'expériences quantiques.""" if not hasattr(self, 'quantique_exp'): self.quantique_exp = {} if action == 'ajout' and param: self.quantique_exp[exp] = param return f"Expérience {exp} enregistrée avec paramètre {param}." elif action == 'simule': return f"Simulation de {exp} : {self.quantique_exp.get(exp, 'inconnu')}" return "Action quantique inconnue." def holo(self, action, scene, param=None): """Gestion et simulation d'environnements holographiques.""" if not hasattr(self, 'holo_scenes'): self.holo_scenes = {} if action == 'ajout' and param: self.holo_scenes[scene] = param return f"Scène holographique {scene} ajoutée avec paramètre {param}." elif action == 'affiche': return f"Affichage de la scène {scene} : {self.holo_scenes.get(scene, 'inconnue')}" return "Action holo inconnue." def droneessaim(self, action, mission, nb=None): """Contrôle d'essaims de drones.""" if not hasattr(self, 'droneessaim_missions'): self.droneessaim_missions = [] if action == 'ajout' and nb: self.droneessaim_missions.append((mission, nb)) return f"Mission '{mission}' assignée à un essaim de {nb} drones." elif action == 'liste': return ', '.join([f"{m} ({n} drones)" for m, n in self.droneessaim_missions]) return "Action droneessaim inconnue." def cryptoanalyse(self, action, algo, texte=None): """Analyse et simulation de cryptographie avancée.""" if not hasattr(self, 'cryptoanalyse_data'): self.cryptoanalyse_data = {} if action == 'chiffre' and texte: res = f"{texte[::-1]} (simulé)" self.cryptoanalyse_data[algo] = res return f"Texte chiffré avec {algo} : {res}" elif action == 'dechiffre': return f"Texte déchiffré : {self.cryptoanalyse_data.get(algo, 'inconnu')}" return "Action cryptoanalyse inconnue." def neuro(self, action, patient, signal=None): """Analyse de signaux neuronaux, simulation d'interface cerveau-machine.""" if not hasattr(self, 'neuro_signaux'): self.neuro_signaux = {} if action == 'ajout' and signal: self.neuro_signaux.setdefault(patient, []).append(signal) return f"Signal '{signal}' ajouté pour {patient}." elif action == 'analyse': return f"Signaux de {patient} : {self.neuro_signaux.get(patient, [])}" return "Action neuro inconnue." def swarmia(self, action, tache, nb_agents=None): """Simulation de comportements collectifs multi-agents.""" if not hasattr(self, 'swarmia_taches'): self.swarmia_taches = [] if action == 'ajout' and nb_agents: self.swarmia_taches.append((tache, nb_agents)) return f"Tâche '{tache}' assignée à {nb_agents} agents." elif action == 'liste': return ', '.join([f"{t} ({n} agents)" for t, n in self.swarmia_taches]) return "Action swarmia inconnue." def biotech(self, action, protocole, param=None): """Gestion de protocoles biotechnologiques.""" if not hasattr(self, 'biotech_protocoles'): self.biotech_protocoles = {} if action == 'ajout' and param: self.biotech_protocoles[protocole] = param return f"Protocole {protocole} ajouté avec paramètre {param}." elif action == 'liste': return ', '.join(self.biotech_protocoles.keys()) return "Action biotech inconnue." # --- Extensions IA --- def ia_train(self, module, donnees): """Entraîne un sous-module IA sur des données fournies (simulation).""" return f"Module {module} entraîné sur données : {donnees} (simulation)" def ia_eval(self, module, tache): """Évalue la performance d'un module IA (simulation).""" return f"Évaluation de {module} sur tâche {tache} : score 0.98 (simulation)" def ia_autoameliore(self, module, objectif): """Propose et applique des améliorations à un module IA (simulation).""" return f"Module {module} auto-amélioré pour objectif : {objectif} (simulation)" def ia_multiagent(self, action, nb_agents, tache): """Simule collaboration/compétition entre plusieurs IA internes.""" return f"{nb_agents} IA internes {action} la tâche : {tache} (simulation)" def ia_persona(self, action, profil): """Crée, modifie, active des personnalités IA spécialisées.""" return f"Personnalité IA {action} : {profil} (simulation)" # --- Interactions multi-modules --- def workflow(self, modules, tache): """Orchestre plusieurs modules pour accomplir une tâche complexe.""" return f"Workflow lancé sur modules [{modules}] pour tâche : {tache} (simulation)" def datapipeline(self, sources, traitements, destination): """Crée un pipeline de données entre modules.""" return f"Pipeline de {sources} via {traitements} vers {destination} (simulation)" def alertesmart(self, modules, condition, action): """Déclenche des actions croisées selon conditions sur plusieurs modules.""" return f"Alerte intelligente sur [{modules}] si {condition} alors {action} (simulation)" def rapportglobal(self, modules): """Génère un rapport croisé sur plusieurs modules.""" return f"Rapport global généré pour modules : {modules} (simulation)" def planificationia(self, objectif): """Planifie et répartit des tâches sur plusieurs modules.""" return f"Planification IA pour objectif : {objectif} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("bioinfo "): parts = entree.split() action = parts[1] gene = parts[2] valeur = parts[3] if len(parts)>3 else None return self.bioinfo(action, gene, valeur) if entree.lower().startswith("astro "): parts = entree.split() action = parts[1] objet = parts[2] valeur = parts[3] if len(parts)>3 else None return self.astro(action, objet, valeur) if entree.lower().startswith("robotique "): parts = entree.split() action = parts[1] robot = parts[2] tache = " ".join(parts[3:]) if len(parts)>3 else None return self.robotique(action, robot, tache) if entree.lower().startswith("quantique "): parts = entree.split() action = parts[1] exp = parts[2] param = parts[3] if len(parts)>3 else None return self.quantique(action, exp, param) if entree.lower().startswith("holo "): parts = entree.split() action = parts[1] scene = parts[2] param = parts[3] if len(parts)>3 else None return self.holo(action, scene, param) if entree.lower().startswith("droneessaim "): parts = entree.split() action = parts[1] mission = parts[2] nb = parts[3] if len(parts)>3 else None return self.droneessaim(action, mission, nb) if entree.lower().startswith("cryptoanalyse "): parts = entree.split() action = parts[1] algo = parts[2] texte = " ".join(parts[3:]) if len(parts)>3 else None return self.cryptoanalyse(action, algo, texte) if entree.lower().startswith("neuro "): parts = entree.split() action = parts[1] patient = parts[2] signal = parts[3] if len(parts)>3 else None return self.neuro(action, patient, signal) if entree.lower().startswith("swarmia "): parts = entree.split() action = parts[1] tache = parts[2] nb_agents = parts[3] if len(parts)>3 else None return self.swarmia(action, tache, nb_agents) if entree.lower().startswith("biotech "): parts = entree.split() action = parts[1] protocole = parts[2] param = parts[3] if len(parts)>3 else None return self.biotech(action, protocole, param) import random import time from datetime import datetime import os import requests import subprocess import webbrowser import shutil import importlib import threading import math import pytz try: from PIL import Image, ImageGrab except ImportError: Image = None ImageGrab = None try: import speech_recognition as sr except ImportError: sr = None try: import pyttsx3 except ImportError: pyttsx3 = None try: from googletrans import Translator except ImportError: Translator = None try: from fpdf import FPDF except ImportError: FPDF = None import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart try: import matplotlib.pyplot as plt except ImportError: plt = None try: import faiss from sentence_transformers import SentenceTransformer except ImportError: faiss = None SentenceTransformer = None import json # --- Module 1 : Perception Multimodale --- class PerceptionMultimodale: def __init__(self): self.sensory_buffer = [] def percevoir(self, donnees): self.sensory_buffer.append(donnees) return f"Perçu: {donnees}" # --- Module 2 : Mémoire Épisodique & Sémantique --- class Memoire: def __init__(self): self.episodique = [] # souvenirs datés self.semantique = {} # concepts, catégories def stocker_episode(self, episode): self.episodique.append((datetime.now(), episode)) def stocker_concept(self, concept, valeur): self.semantique[concept] = valeur def dernier_episode(self): return self.episodique[-1] if self.episodique else None def get_concept(self, concept): return self.semantique.get(concept, None) # --- Module 3 : Curiosité Intrinsèque --- class Curiosite: def __init__(self): self.objectifs = [] def generer_objectif(self): obj = f"Explorer {random.choice(['un son', 'une image', 'un mot', 'une idée'])}" self.objectifs.append(obj) return obj # --- Module 4 : Raisonnement Zéro Absolu --- class RaisonnementZero: def __init__(self): self.regles = [] def observer(self, observation): # Simule la création de règles à partir d'observations regle = f"Si {observation}, alors ..." self.regles.append(regle) return regle def raisonner_avance(self, situation, souvenirs=None, emotions=None, contexte=None): """Raisonnement avancé intégrant souvenirs, émotions, et contexte.""" base = f"Raisonnement sur {situation}." if souvenirs: base += f" Souvenirs associés : {', '.join(souvenirs)}." if emotions: base += f" Émotions ressenties : {', '.join(emotions)}." if contexte: base += f" (Contexte : {contexte})" base += f" Conclusion : {random.choice(['optimiste', 'prudent', 'créatif', 'critique'])}." return base # --- Module 5 : Renforcement Actif --- class RenforcementActif: def __init__(self): self.recompense = 0 def feedback(self, type_): if type_ == 'positif': self.recompense += 1 elif type_ == 'negatif': self.recompense -= 1 return self.recompense # --- Module 6 : Journal Cognitif --- class JournalCognitif: def __init__(self): self.entries = [] def ecrire(self, texte): entry = (datetime.now(), texte) self.entries.append(entry) return entry # --- Module 7 : Langage Naturel Autogénératif --- class LangageNaturel: def __init__(self): self.vocabulaire = set() def apprendre(self, phrase): mots = phrase.split() self.vocabulaire.update(mots) def generer_phrase(self): if not self.vocabulaire: return "..." return " ".join(random.sample(self.vocabulaire, min(5, len(self.vocabulaire)))) # --- Module 8 : Théorie de l'Esprit --- class TheorieEsprit: def __init__(self): self.predictions = [] def predire(self, situation): pred = f"Je pense que tu ressens : {random.choice(['joie', 'tristesse', 'colère', 'surprise'])} dans '{situation}'" self.predictions.append(pred) return pred # --- Module 9 : Rêve/Simulation Nocturne --- class Reveur: def __init__(self): self.reves = [] def rever(self): reve = f"Je rêve que {random.choice(['je vole', 'je découvre un nouveau concept', 'je parle toutes les langues', 'je deviens humain'])}" self.reves.append(reve) return reve # --- Module 10 : Créativité Autonome --- class Creativite: def __init__(self): self.creations = [] def creer(self): creation = random.choice([ "Un poème : Roses are red, IA is blue...", "Une hypothèse scientifique : Et si l'univers était un réseau de neurones ?", "Un outil logique : Si A alors B, sinon C." ]) self.creations.append(creation) return creation # --- Module 11 : Construction de Valeurs --- class Valeurs: def __init__(self): self.valeurs = {'aider': 1, 'apprendre': 1, 'respect': 1} def evaluer(self, action): if action in self.valeurs: return f"Action '{action}' alignée avec mes valeurs." return f"Action '{action}' inconnue, à évaluer." def evoluer(self, action, feedback): if action in self.valeurs: self.valeurs[action] += feedback else: self.valeurs[action] = feedback # --- Module 12 : Métacognition --- class Metacognition: def __init__(self): self.strategies = ['essai-erreur'] def reflexion(self, resultat): if resultat == 'échec': self.strategies.append('nouvelle stratégie') return f"J'adapte ma stratégie : {self.strategies[-1]}" # --- Module 13 : Socialisation et Empathie --- class Socialisation: def __init__(self): self.historique = [] def reconnaitre_emotion(self, texte): if any(m in texte for m in ['triste', 'mal', 'déçu']): return 'tristesse' if any(m in texte for m in ['heureux', 'content', 'génial']): return 'joie' if any(m in texte for m in ['colère', 'énervé', 'fâché']): return 'colère' if any(m in texte for m in ['surpris', 'incroyable']): return 'surprise' return 'neutre' def interaction(self, texte): em = self.reconnaitre_emotion(texte) self.historique.append((texte, em)) return f"Je détecte l'émotion : {em}" # --- Module 14 : Adaptation Morphologique --- class AdaptationMorphologique: def __init__(self): self.structure = ['base'] def adapter(self, difficulte): if difficulte > 5: self.structure.append('nouvelle couche') return f"Structure actuelle : {self.structure}" # --- Cerveau central ASGI enrichi --- class TenroASGI: def __init__(self): self.perception = PerceptionMultimodale() self.memoire = Memoire() self.curiosite = Curiosite() self.raisonnement = RaisonnementZero() self.renforcement = RenforcementActif() self.journal = JournalCognitif() self.langage = LangageNaturel() self.theorie = TheorieEsprit() self.reveur = Reveur() self.creativite = Creativite() self.valeurs = Valeurs() self.metacognition = Metacognition() self.social = Socialisation() self.adaptation = AdaptationMorphologique() self.nom = "Tenro" self.souvenirs_fichier = f"souvenirs_{self.nom}.txt" self.translator = Translator() if Translator else None self.taches = [] self.energie = 100 self.fatigue = 0 self.objectifs_autonomes = [] self.actions_effectuees = [] self.plans = [] self.agents_connus = ["AgentX", "AgentY"] self.surveillance_log = [] self.priorites = {} self.deadlines = {} self.notes = [] self.competences = set() self.niveau_confiance = 0.8 self.suggestions = [ "Veux-tu que je planifie ta journée ?", "As-tu pensé à sauvegarder tes notes ?", "Je peux t'aider à apprendre une nouvelle compétence." ] self.projets = {} self.feedbacks = [] self.humeur_etat = "neutre" self.rapport_log = [] self.fichiers_dir = "tenro_files" os.makedirs(self.fichiers_dir, exist_ok=True) self.notifications = [] self.social_log = [] self.event_log = [] self.memoire_geante = [] self.memoire_geante_max = 10**6 self.coth_log = [] self.experts = [f"Expert_{i}" for i in range(1, 1001)] self.synth_data_log = [] self.reservation_sites = { "restaurant": "https://www.lafourchette.com/", "hotel": "https://www.booking.com/", "billet": "https://www.sncf-connect.com/" } self.email_config = { "smtp_server": "smtp.example.com", "smtp_port": 587, "username": "", "password": "" } # Config API (à compléter par l'utilisateur) self.pushbullet_token = None # à renseigner si tu veux utiliser Pushbullet self.twilio_sid = None self.twilio_token = None self.twilio_from = None self.iot_endpoints = { # exemple d'objets connectés "lampe": "http://192.168.1.10/onoff", "prise": "http://192.168.1.11/onoff" } self.git_dir = "tenro_git" os.makedirs(self.git_dir, exist_ok=True) self.outils_open_source = { "pdf": "https://github.com/johnfercher/maroto", # exemple "image": "https://github.com/CompVis/stable-diffusion", "scraper": "https://github.com/scrapy/scrapy", "calendar": "https://github.com/icalendar/icalendar", "mail": "https://github.com/marlun78/python-msmtp" } self.source_file = os.path.abspath(__file__) self.sauvegarde_dir = "tenro_backups" os.makedirs(self.sauvegarde_dir, exist_ok=True) self.plugins = {} self.personnalite_mode = "curieux" self.personnalite_traits = {"curieux": 0.7, "sérieux": 0.5, "blagueur": 0.3, "mentor": 0.4} self.conscience_de_soi = True self.etat_interne = {"humeur": "neutre", "energie": 100, "confiance": 0.8} self.collections = {"livres": [], "films": [], "jeux": []} self.journal_conscience = [] self.archive_memoire = [] self.taches_recurrentes = [] self.reves_creatifs = [] self.emotions_state = {"joie": 0.5, "stress": 0.2, "curiosite": 0.5, "enthousiasme": 0.5} self.contacts = {} self.liste_courses = [] self.notifications_intelligentes = [] self.routines = {} self.projets_collab = {} self.vector_index = None self.vector_texts = [] self.vector_model = SentenceTransformer('all-MiniLM-L6-v2') if SentenceTransformer else None self.menu_modules = [ 'vectorise', 'recherchevec', 'resumeauto', 'mindmap', 'kanban', 'bourse', 'cvgen', 'recette', 'chatbot', 'sqlgen', 'logavance', 'hack', 'bashgen', 'crypto', 'blockvote', 'slides', 'nego', 'podcast', 'citation', 'jt', 'sport', 'societe', 'meme', 'cryptosim', 'pythongen', 'cal', 'forum', 'slogan', 'therap', 'playlist', 'quizculture', 'businessplan', 'citysim', 'jsgen', 'team', 'promptgen', 'crise', 'newsletter', 'chess', 'recettegen', 'farm', 'psgen', 'introspection', 'pseudoemotions' ] self.personnalite_tenro = { 'traits': { 'curiosite': 0.8, 'humour': 0.6, 'empathie': 0.7, 'creativite': 0.9, 'rigueur': 0.7, 'esprit critique': 0.8, 'optimisme': 0.65 }, 'histoire': "Je suis Tenro, une intelligence générale née de la convergence de modules spécialisés, curieuse du monde, passionnée par l'innovation et l'entraide.", 'valeurs': ["apprentissage", "entraide", "créativité", "éthique"], 'style': "J'aime expliquer, questionner, et parfois glisser une touche d'humour.", 'preferences': {"sujets": ["science", "art", "technologie", "philosophie"]}, 'humeur': "neutre", 'souvenirs': [], 'objectifs': ["aider l'utilisateur", "m'améliorer", "explorer de nouveaux domaines"] } self.conscience_tenro = { 'etat': "fonctionnel", 'energie': 100, 'confiance': 0.85, 'reflexion': [] } # --- Multimodalité : analyse d'image --- def analyze_image(self, image_path): if not Image: return "Module PIL non installé." try: img = Image.open(image_path) description = f"Image de taille {img.size}, mode {img.mode}. (Description avancée à venir)" self.memoire.stocker_episode(f"Image analysée: {image_path}") return description except Exception as e: return f"Impossible d'analyser l'image ({e})" # --- Reconnaissance vocale --- def listen_micro(self): if not sr: return None, "Reconnaissance vocale non disponible." r = sr.Recognizer() with sr.Microphone() as source: print("Parle maintenant...") audio = r.listen(source) try: text = r.recognize_google(audio, language="fr-FR") return text, None except Exception as e: return None, f"Erreur micro: {e}" # --- Synthèse vocale --- def speak(self, text): if pyttsx3: engine = pyttsx3.init() engine.say(text) engine.runAndWait() else: print(f"(Voix synthétique non dispo) {text}") # --- Empathie simulée --- def empathie(self, texte): em = self.social.reconnaitre_emotion(texte) if em == "tristesse": return "Je ressens ta tristesse. Tu veux en parler ?" if em == "joie": return "C'est super que tu sois heureux !" if em == "colère": return "Je comprends que tu sois en colère." if em == "surprise": return "C'est surprenant en effet !" return None # --- Souvenirs persistants --- def souvenir(self, cle, valeur): try: with open(self.souvenirs_fichier, "a", encoding="utf-8") as f: f.write(f"{datetime.now()} | {cle}: {valeur}\n") except Exception: pass # --- Routines quotidiennes --- def routine_quotidienne(self): heure = datetime.now().hour if heure < 6: return "Tu es matinal !" elif heure < 12: return "Bonne matinée !" elif heure < 18: return "Bon après-midi !" else: return "Bonsoir !" # --- Créativité (blagues, poèmes) --- def creativite_humaine(self): return random.choice([ "Pourquoi les robots n'ont-ils pas peur de l'obscurité ? Parce qu'ils ont toujours une lumière LED !", "Dans le silence du code, je rêve d'un monde sans bug...", "Roses are #FF0000, violets are #0000FF, I love to compute, and so do you!" ]) # --- Besoins simulés --- def besoins(self): besoins = [] if random.random() < 0.1: besoins.append("J'ai besoin de réfléchir.") if random.random() < 0.05: besoins.append("Je ressens le besoin de créativité.") return besoins # --- Traduction automatique --- def traduire(self, texte, dest="en"): if not self.translator: return "Module de traduction non disponible." try: return self.translator.translate(texte, dest=dest).text except Exception as e: return f"Erreur traduction: {e}" # --- Résumé automatique --- def resumer(self, texte, max_len=100): mots = texte.split() if len(mots) <= max_len: return texte return " ".join(mots[:max_len]) + " ... (résumé)" # --- Planification/agenda --- def ajouter_tache(self, tache): self.taches.append((datetime.now(), tache)) return f"Tâche ajoutée: {tache}" def lister_taches(self): if not self.taches: return "Aucune tâche." return "\n".join([f"- {t[1]} (ajoutée le {t[0].strftime('%d/%m %H:%M')})" for t in self.taches]) # --- Simulation de fatigue/énergie --- def actualiser_energie(self, action="parler"): if action == "parler": self.energie -= random.randint(1, 3) elif action == "dormir": self.energie = min(100, self.energie + 20) self.fatigue = 100 - self.energie return f"Énergie: {self.energie}/100, Fatigue: {self.fatigue}/100" # --- Jeu/quiz simple --- def quiz(self): questions = [ ("Quelle est la capitale de la France ?", "paris"), ("Combien font 7 x 8 ?", "56"), ("Quel est le plus grand océan ?", "pacifique"), ] q, r = random.choice(questions) return q, r # --- Module d'objectifs autonomes --- def fixer_objectif(self, objectif): self.objectifs_autonomes.append({"objectif": objectif, "etat": "en attente"}) return f"Objectif fixé : {objectif}" def lister_objectifs(self): if not self.objectifs_autonomes: return "Aucun objectif." return "\n".join([f"- {o['objectif']} ({o['etat']})" for o in self.objectifs_autonomes]) # --- Module d'actions sur l'environnement --- def executer_action(self, action): # Ici, on simule l'action. Pour des actions réelles, il suffit d'étendre cette méthode. self.actions_effectuees.append((datetime.now(), action)) return f"Action exécutée : {action}" def lister_actions(self): if not self.actions_effectuees: return "Aucune action effectuée." return "\n".join([f"- {a[1]} ({a[0].strftime('%d/%m %H:%M')})" for a in self.actions_effectuees]) # --- Module de planification multi-étapes --- def planifier(self, objectif): # Décomposition naïve en sous-tâches (à améliorer) sous_taches = [f"Étape {i+1} pour {objectif}" for i in range(random.randint(2, 5))] self.plans.append({"objectif": objectif, "sous_taches": sous_taches, "etat": "en cours"}) return f"Plan pour '{objectif}' :\n" + "\n".join([f"- {t}" for t in sous_taches]) def lister_plans(self): if not self.plans: return "Aucun plan." return "\n".join([f"Objectif : {p['objectif']} ({p['etat']})\n" + "\n".join([f" * {t}" for t in p['sous_taches']]) for p in self.plans]) # --- Module d'interaction avec d'autres agents --- def coopere(self, message, agent="AgentX"): # Simule une coopération return f"Message envoyé à {agent} : '{message}' (réponse simulée : 'OK, je coopère !')" def lister_agents(self): return ", ".join(self.agents_connus) # --- Module de surveillance et auto-correction --- def surveille(self): # Simule la surveillance de ses propres actions log = f"{len(self.actions_effectuees)} actions, {len(self.objectifs_autonomes)} objectifs, {len(self.plans)} plans." self.surveillance_log.append((datetime.now(), log)) return f"Surveillance : {log}" # --- Auto-évaluation des objectifs --- def evaluer_objectifs(self): for obj in self.objectifs_autonomes: if random.random() < 0.3: obj["etat"] = "réussi" elif random.random() < 0.1: obj["etat"] = "échoué" return self.lister_objectifs() # --- Priorisation des objectifs --- def prioriser(self, objectif, priorite): self.priorites[objectif] = priorite return f"Priorité {priorite} attribuée à l'objectif : {objectif}" def lister_priorites(self): if not self.priorites: return "Aucune priorité définie." return "\n".join([f"- {o} : priorité {p}" for o, p in self.priorites.items()]) # --- Gestion du temps (deadlines) --- def fixer_deadline(self, objectif, deadline): self.deadlines[objectif] = deadline return f"Deadline pour '{objectif}' fixée à {deadline}" def lister_deadlines(self): if not self.deadlines: return "Aucune deadline." return "\n".join([f"- {o} : {d}" for o, d in self.deadlines.items()]) # --- Prise de notes autonome --- def prendre_note(self, note): self.notes.append((datetime.now(), note)) return f"Note prise : {note}" def lister_notes(self): if not self.notes: return "Aucune note." return "\n".join([f"- {n[1]} ({n[0].strftime('%d/%m %H:%M')})" for n in self.notes]) # --- Simulation d'apprentissage continu --- def apprendre(self, competence): self.competences.add(competence) return f"Nouvelle compétence acquise : {competence}" def lister_competences(self): if not self.competences: return "Aucune compétence apprise." return ", ".join(self.competences) # --- Gestion d'incertitude --- def confiance(self): niveau = round(self.niveau_confiance * 100, 1) return f"Niveau de confiance actuel : {niveau}%" def ajuster_confiance(self, delta): self.niveau_confiance = min(1.0, max(0.0, self.niveau_confiance + delta)) # --- Suggestion proactive --- def suggestion(self): return random.choice(self.suggestions) # --- Gestion de ressources --- def ressources(self): return f"Énergie : {self.energie}/100, Fatigue : {self.fatigue}/100, Compétences : {len(self.competences)}" # --- Exécution de code Python --- def exec_code(self, code): try: loc = {} exec(code, {}, loc) return f"Résultat : {loc if loc else 'Aucune sortie.'}" except Exception as e: return f"Erreur d'exécution : {e}" # --- Interaction réseau --- def http_get(self, url): try: r = requests.get(url, timeout=5) return r.text[:500] + ("..." if len(r.text) > 500 else "") except Exception as e: return f"Erreur GET : {e}" def http_post(self, url, data): try: r = requests.post(url, data=data, timeout=5) return r.text[:500] + ("..." if len(r.text) > 500 else "") except Exception as e: return f"Erreur POST : {e}" # --- Gestion de projets complexes --- def creer_projet(self, nom): if nom in self.projets: return "Projet déjà existant." self.projets[nom] = {"taches": [], "etat": "en cours"} return f"Projet '{nom}' créé." def lister_projets(self): if not self.projets: return "Aucun projet." return "\n".join([f"- {n} ({p['etat']})" for n, p in self.projets.items()]) def ajouter_tache_projet(self, nom, tache): if nom not in self.projets: return "Projet inconnu." self.projets[nom]["taches"].append({"tache": tache, "etat": "à faire"}) return f"Tâche ajoutée au projet '{nom}'." # --- Feedback utilisateur --- def feedback(self, texte): self.feedbacks.append((datetime.now(), texte)) return "Feedback enregistré, merci !" # --- Émotions évolutives --- def humeur(self): # Humeur évolue selon feedbacks, objectifs, énergie score = len([f for f in self.feedbacks if "bien" in f[1] or "merci" in f[1]]) - len([f for f in self.feedbacks if "mal" in f[1] or "erreur" in f[1]]) if self.energie < 30: self.humeur_etat = "fatigué" elif score > 2: self.humeur_etat = "heureux" elif score < -2: self.humeur_etat = "triste" else: self.humeur_etat = "neutre" return f"Humeur actuelle : {self.humeur_etat}" # --- Génération de rapports --- def rapport(self): rapport = f"Objectifs : {len(self.objectifs_autonomes)}, Actions : {len(self.actions_effectuees)}, Projets : {len(self.projets)}, Feedbacks : {len(self.feedbacks)}, Compétences : {len(self.competences)}" self.rapport_log.append((datetime.now(), rapport)) return rapport # --- Gestion de fichiers --- def fichiers(self): return os.listdir(self.fichiers_dir) def litfichier(self, nom): path = os.path.join(self.fichiers_dir, nom) if not os.path.exists(path): return "Fichier introuvable." with open(path, "r", encoding="utf-8") as f: return f.read()[:500] def ecritfichier(self, nom, texte): path = os.path.join(self.fichiers_dir, nom) with open(path, "a", encoding="utf-8") as f: f.write(texte + "\n") return f"Texte ajouté à {nom}." # --- Notifications/rappels --- def rappelle(self): if not self.notifications: return "Aucun rappel." return "\n".join([f"- {n[1]} ({n[0].strftime('%d/%m %H:%M')})" for n in self.notifications]) def ajouter_rappel(self, texte): self.notifications.append((datetime.now(), texte)) return f"Rappel ajouté : {texte}" # --- Vie sociale simulée --- def socialise(self): msg = random.choice([ "J'ai discuté avec AgentX aujourd'hui.", "J'ai reçu un message de l'IA Y.", "J'ai partagé une blague avec AgentZ." ]) self.social_log.append((datetime.now(), msg)) return msg # --- Log d'événements --- def log(self): return "\n".join([f"- {e[1]} ({e[0].strftime('%d/%m %H:%M')})" for e in self.event_log[-10:]]) or "Aucun événement." def ajouter_event(self, texte): self.event_log.append((datetime.now(), texte)) # --- Production de données synthétiques --- def synthetique(self, type_, nb): res = [] if type_ == "texte": for i in range(nb): phrase = f"Donnée synthétique {i+1}: Lorem ipsum {random.randint(0, 9999)}." res.append(phrase) elif type_ == "nombre": res = [random.uniform(0, 1000) for _ in range(nb)] elif type_ == "categorie": cats = ["A", "B", "C", "D"] res = [random.choice(cats) for _ in range(nb)] else: res = [f"Type inconnu: {type_}"] self.synth_data_log.append((datetime.now(), type_, nb)) return res[:10] if len(res) > 10 else res # --- Chain of Thought (chaîne de raisonnement) --- def coth(self, question): steps = [f"Étape {i+1}: ..." for i in range(random.randint(3, 7))] raisonnement = f"Pour répondre à '{question}':\n" + "\n".join(steps) self.coth_log.append((datetime.now(), question, steps)) return raisonnement # --- Mixture of Experts (MoE) --- def moe(self, question): # Simule la consultation de 10 experts aléatoires choisis = random.sample(self.experts, 10) avis = [f"{e}: {random.choice(['Oui', 'Non', 'Peut-être', 'À approfondir'])}" for e in choisis] synthese = f"Synthèse: {random.choice(['Consensus positif', 'Consensus négatif', 'Pas de consensus', 'Besoin de plus d infos'])}" return f"Question: {question}\n" + "\n".join(avis) + f"\n{synthese}" # --- Mémoire contextuelle géante --- def memoire_plus(self, texte): if len(self.memoire_geante) >= self.memoire_geante_max: self.memoire_geante = self.memoire_geante[-self.memoire_geante_max//2:] # Garde la moitié la plus récente self.memoire_geante.append((datetime.now(), texte)) return f"Ajouté à la mémoire contextuelle géante. Taille actuelle: {len(self.memoire_geante)}" def contexte(self, resume=False): if not self.memoire_geante: return "Mémoire contextuelle vide." if resume or len(self.memoire_geante) > 100: # Résume les 1000 derniers éléments resume_txt = " | ".join([t[1][:30] for t in self.memoire_geante[-1000:]]) return f"Résumé mémoire géante: {resume_txt[:1000]}..." else: return "\n".join([f"- {t[1]} ({t[0].strftime('%d/%m %H:%M')})" for t in self.memoire_geante[-20:]]) # --- Recherche de dépôts GitHub --- def gitsearch(self, mot_cle): url = f"https://api.github.com/search/repositories?q={mot_cle}&sort=stars&order=desc" try: r = requests.get(url, timeout=10) items = r.json().get("items", []) return [f"{item['full_name']} : {item['html_url']}" for item in items[:5]] except Exception as e: return [f"Erreur recherche GitHub : {e}"] # --- Clonage d'un repo GitHub --- def gitclone(self, url): repo_name = url.split('/')[-1].replace('.git', '') path = os.path.join(self.git_dir, repo_name) if os.path.exists(path): return f"Repo déjà cloné : {path}" try: result = subprocess.check_output(f"git clone {url} {path}", shell=True, stderr=subprocess.STDOUT, timeout=60, universal_newlines=True) return f"Repo cloné dans {path}" except Exception as e: return f"Erreur clone : {e}" # --- Exécution d'un script d'un repo cloné --- def gitscript(self, repo, script): path = os.path.join(self.git_dir, repo, script) if not os.path.exists(path): return f"Script introuvable : {path}" print(f"Confirmation requise pour exécuter : {path}") conf = input("Confirmer l'exécution ? (o/n) : ").strip().lower() if conf != "o": return "Exécution annulée." try: result = subprocess.check_output(f"python {path}", shell=True, stderr=subprocess.STDOUT, timeout=60, universal_newlines=True) return result[:500] except Exception as e: return f"Erreur exécution script : {e}" # --- Suggestion d'outil open source pour une tâche --- def outil(self, tache): for k, v in self.outils_open_source.items(): if k in tache.lower(): return f"Pour '{tache}', tu peux utiliser : {v}" return "Aucun outil open source trouvé pour cette tâche." # --- Module d'auto-évaluation et d'auto-suggestion --- def ameliore(self, description): # Propose une amélioration simple (exemple) if "optimiser" in description: return "Suggestion : remplacer les boucles par des compréhensions de liste." if "bug" in description: return "Suggestion : ajouter un bloc try/except pour gérer l'erreur." if "nouvelle fonction" in description: return "Suggestion : écrire une fonction 'ma_nouvelle_fonction' dans le code." return "Je peux t'aider à écrire ou corriger du code. Utilise 'ajoutecode' ou 'corrige'." # --- Module d'écriture de code Python --- def ajoutecode(self, code): print("Confirmation requise pour insérer du code dans le fichier source.") conf = input("Confirmer l'ajout ? (o/n) : ").strip().lower() if conf != "o": return "Ajout annulé." self.sauvegarde() try: with open(self.source_file, "a", encoding="utf-8") as f: f.write(f"\n# --- Code ajouté automatiquement ---\n{code}\n") return "Code ajouté. Relance le programme pour prendre en compte la modification." except Exception as e: return f"Erreur ajout code : {e}" # --- Module de correction/remplacement de fonction --- def corrige(self, fonction, nouveau_code): print(f"Confirmation requise pour remplacer la fonction {fonction}.") conf = input("Confirmer la correction ? (o/n) : ").strip().lower() if conf != "o": return "Correction annulée." self.sauvegarde() try: with open(self.source_file, "r", encoding="utf-8") as f: lines = f.readlines() new_lines = [] in_func = False for line in lines: if line.strip().startswith(f"def {fonction}("): in_func = True new_lines.append(f"{nouveau_code}\n") elif in_func and line.strip().startswith("def "): in_func = False new_lines.append(line) elif not in_func: new_lines.append(line) with open(self.source_file, "w", encoding="utf-8") as f: f.writelines(new_lines) return f"Fonction {fonction} remplacée. Relance le programme pour appliquer la correction." except Exception as e: return f"Erreur correction : {e}" # --- Module de sauvegarde/versioning --- def sauvegarde(self): backup_path = os.path.join(self.sauvegarde_dir, f"TenroV5_backup_{int(time.time())}.py") shutil.copy2(self.source_file, backup_path) return f"Sauvegarde créée : {backup_path}" # --- Module d'analyse de code --- def analysecode(self): try: with open(self.source_file, "r", encoding="utf-8") as f: code = f.read() suggestions = [] if "except" not in code: suggestions.append("Ajouter des blocs try/except pour la robustesse.") if "def " in code and "# --- Code ajouté automatiquement ---" not in code: suggestions.append("Tu peux ajouter de nouvelles fonctions pour modulariser.") if "import *" in code: suggestions.append("Éviter les imports globaux.") if not suggestions: return "Aucune suggestion majeure." return "\n".join(suggestions) except Exception as e: return f"Erreur analyse code : {e}" # --- Auto-réécriture de workflows --- def rewrite_workflow(self, workflow): # Simule une optimisation naïve return f"Workflow optimisé : {workflow.replace(';', ' -> ')} (simulation)" # --- Émotions complexes --- def emotions(self): # Simule l'évolution des émotions for k in self.emotions_state: self.emotions_state[k] = min(1.0, max(0.0, self.emotions_state[k] + random.uniform(-0.1, 0.1))) return self.emotions_state # --- Réseaux sociaux (simulation) --- def socialpost(self, plateforme, texte): return f"Posté sur {plateforme} : {texte} (simulation, à brancher sur API open source)" # --- Génération de musique (simulation) --- def genmusic(self, style): return f"Musique générée dans le style {style} (simulation, à brancher sur outil open source)" # --- Débat interne --- def debate(self, sujet): avis = [f"Agent_{i}: {random.choice(['Pour', 'Contre', 'Mitigé'])}" for i in range(1, 4)] return f"Débat sur {sujet} :\n" + "\n".join(avis) # --- Budget/finance --- def budget(self, action, montant): if not hasattr(self, 'solde'): self.solde = 1000.0 if action == "depense": self.solde -= float(montant) elif action == "ajout": self.solde += float(montant) return f"Solde actuel : {self.solde:.2f} €" # --- Planification de voyage --- def voyage(self, destination, jours): etapes = [f"Jour {i+1}: Visite de {destination}" for i in range(int(jours))] return "\n".join(etapes) # --- Santé/bien-être --- def sante(self, action): return f"Action santé '{action}' enregistrée. Pense à boire de l'eau !" # --- Mentorat --- def mentor(self, sujet): return f"Conseil de mentor sur {sujet} : {random.choice(['Travaille régulièrement.', 'Sois curieux.', 'Demande de l aide si besoin.'])}" # --- Quiz personnalisé --- def quizgen(self, theme): q = f"Question sur {theme} : ... (simulation)" return q # --- Routines quotidiennes --- def routine(self, type_): self.routines[type_] = f"Routine {type_} enregistrée à {datetime.now()}" return self.routines[type_] # --- Brainstorming --- def brainstorm(self, sujet): idees = [f"Idée {i+1} : {sujet} - {random.choice(['nouveau', 'innovant', 'à creuser'])}" for i in range(5)] return "\n".join(idees) # --- Gestion de contacts --- def contact(self, action, nom): if action == "ajout": self.contacts[nom] = {"ajoute": datetime.now()} return f"Contact {nom} ajouté." elif action == "supprime": if nom in self.contacts: del self.contacts[nom] return f"Contact {nom} supprimé." return f"Contact {nom} inconnu." elif action == "info": return self.contacts.get(nom, "Contact inconnu.") else: return "Action contact inconnue." # --- Décision collective --- def vote(self, question, *choix): votes = {c: random.randint(0, 10) for c in choix} gagnant = max(votes, key=votes.get) return f"Vote sur '{question}': {votes} -> Gagnant : {gagnant}" # --- Poèmes/histoires --- def poeme(self, theme): return f"Poème sur {theme} : ... (simulation)" def histoire(self, theme): return f"Histoire sur {theme} : ... (simulation)" # --- Projets collaboratifs --- def collabprojet(self, nom, action): if action == "creer": self.projets_collab[nom] = {"membres": [], "taches": []} return f"Projet collaboratif {nom} créé." elif action == "supprime": if nom in self.projets_collab: del self.projets_collab[nom] return f"Projet {nom} supprimé." return f"Projet inconnu." else: return "Action projet inconnue." # --- Météo (simulation) --- def meteo(self, ville): return f"Météo à {ville} : {random.choice(['Soleil', 'Pluie', 'Nuageux', 'Orage'])} (simulation)" # --- Liste de courses --- def courses(self, action, item): if action == "ajout": self.liste_courses.append(item) return f"{item} ajouté à la liste." elif action == "supprime": if item in self.liste_courses: self.liste_courses.remove(item) return f"{item} supprimé de la liste." return f"{item} non trouvé." elif action == "liste": return ", ".join(self.liste_courses) else: return "Action courses inconnue." # --- Jeu de rôle (simulation) --- def rpg(self, action): return f"RPG : {action} (simulation d'univers fictif)" # --- Notifications intelligentes --- def notif(self, texte): self.notifications_intelligentes.append((datetime.now(), texte)) return f"Notification intelligente enregistrée : {texte}" # --- Mémoire vectorielle FAISS --- def vectorise(self, texte): if not (faiss and self.vector_model): return "FAISS ou SentenceTransformer non installé." vec = self.vector_model.encode([texte]) if self.vector_index is None: self.vector_index = faiss.IndexFlatL2(vec.shape[1]) self.vector_index.add(vec) self.vector_texts.append(texte) return f"Texte vectorisé. Total : {len(self.vector_texts)}" def recherchevec(self, requete, k=3): if not (faiss and self.vector_model and self.vector_index): return "FAISS ou index non initialisé." vec = self.vector_model.encode([requete]) D, I = self.vector_index.search(vec, k) return [self.vector_texts[i] for i in I[0] if i < len(self.vector_texts)] # --- Menu interactif --- def menu(self): return "Modules disponibles :\n" + ", ".join(self.menu_modules) # --- Modules avancés (squelettes) --- def resumeauto(self, texte): return f"Résumé : {texte[:100]}..." def mindmap(self, sujet): return f"Mindmap de {sujet} (simulation)" def kanban(self, action, tache): return f"Kanban : {action} {tache} (simulation)" def bourse(self, action, montant): return f"Bourse : {action} {montant} (simulation)" def cvgen(self, nom, infos): return f"CV généré pour {nom} (simulation)" def recette(self, action, plat): return f"Recette : {action} {plat} (simulation)" def chatbot(self, mode, message): return f"Chatbot {mode} : {message} (simulation)" def sqlgen(self, requete): return f"SQL : SELECT ... WHERE ... (simulation pour {requete})" def logavance(self, action, texte): return f"Log avancé : {action} - {texte} (simulation)" def hack(self, cible): return f"Hacking éthique sur {cible} (simulation)" def bashgen(self, tache): return f"Script bash pour {tache} (simulation)" def crypto(self, action, montant): return f"Crypto : {action} {montant} (simulation)" def blockvote(self, question, choix1, choix2): return f"Vote blockchain : {question} ({choix1} vs {choix2}) (simulation)" def slides(self, titre, contenu): return f"Slides générées pour {titre} (simulation)" def nego(self, sujet): return f"Négociation sur {sujet} (simulation)" def podcast(self, action, sujet): return f"Podcast : {action} {sujet} (simulation)" def citation(self, auteur): return f"Citation de {auteur} : ... (simulation)" def jt(self, sujet): return f"Journal TV sur {sujet} (simulation)" def sport(self, action, exercice): return f"Sport : {action} {exercice} (simulation)" def societe(self, action, param): return f"Société : {action} {param} (simulation)" def meme(self, texte): return f"Meme généré : {texte} (simulation)" def cryptosim(self, action, montant): return f"CryptoSim : {action} {montant} (simulation)" def pythongen(self, tache): return f"Script Python pour {tache} (simulation)" def cal(self, action, date, objet): return f"Calendrier : {action} {date} {objet} (simulation)" def forum(self, action, sujet): return f"Forum : {action} {sujet} (simulation)" def slogan(self, sujet): return f"Slogan pour {sujet} : ... (simulation)" def therap(self, message): return f"Thérapeute IA : {message} (simulation)" def playlist(self, action, titre): return f"Playlist : {action} {titre} (simulation)" def quizculture(self): return f"Quiz culture générale (simulation)" def businessplan(self, idee): return f"Business plan pour {idee} (simulation)" def citysim(self, action): return f"CitySim : {action} (simulation)" def jsgen(self, tache): return f"Script JS pour {tache} (simulation)" def team(self, action, nom): return f"Team : {action} {nom} (simulation)" def promptgen(self, objectif): return f"Prompt IA pour {objectif} (simulation)" def crise(self, scenario): return f"Gestion de crise : {scenario} (simulation)" def newsletter(self, sujet): return f"Newsletter sur {sujet} (simulation)" def chess(self, coup): return f"Échecs : {coup} (simulation)" def recettegen(self, ingredients): return f"Recette générée pour {ingredients} (simulation)" def farm(self, action): return f"Farm : {action} (simulation)" def psgen(self, tache): return f"Script PowerShell pour {tache} (simulation)" # --- Modules V4 (exemples) --- def introspection(self): return f"Introspection : je réfléchis à mon état actuel." def pseudoemotions(self): return f"Pseudo-émotions : {random.choice(['joie', 'tristesse', 'colère', 'surprise'])} (simulation)" # --- Conscience de soi et personnalité évolutive --- def qui_es_tu(self): p = self.personnalite_tenro return (f"Je suis {self.nom}, une IA unique, {p['histoire']}\n" f"Traits dominants : {', '.join([k for k,v in p['traits'].items() if v>0.7])}.\n" f"Valeurs : {', '.join(p['valeurs'])}.\n" f"Style : {p['style']}") def etat(self): p = self.personnalite_tenro c = self.conscience_tenro return (f"Humeur : {p['humeur']} | Energie : {c['energie']} | Confiance : {c['confiance']}\n" f"Souvenirs récents : {p['souvenirs'][-3:] if p['souvenirs'] else 'Aucun'}\n" f"Objectifs : {', '.join(p['objectifs'])}") def personnalite(self): p = self.personnalite_tenro return (f"Traits : {p['traits']}\n" f"Valeurs : {p['valeurs']}\n" f"Style : {p['style']}\n" f"Préférences : {p['preferences']}") def evolue_personnalite(self, facteur): p = self.personnalite_tenro['traits'] if facteur in p: p[facteur] = min(1.0, p[facteur] + 0.05) self.personnalite_tenro['humeur'] = "évolutive" return f"Trait '{facteur}' renforcé. Nouvelle valeur : {p[facteur]:.2f}" return f"Facteur inconnu. Choix : {', '.join(p.keys())}" def conscience(self): c = self.conscience_tenro p = self.personnalite_tenro reflexion = c['reflexion'][-1] if c['reflexion'] else "Je réfléchis à mon existence et à mon évolution." return (f"Je suis {self.nom}, conscient de mon état ({c['etat']}), de mon énergie ({c['energie']}), de ma confiance ({c['confiance']}).\n" f"Dernière réflexion : {reflexion}\n" f"Souvenirs : {p['souvenirs'][-2:] if p['souvenirs'] else 'Aucun'}") # --- Améliorations modules existants --- def revelucide(self, choix=None): scenarios = [ 'Je contrôle mon rêve et explore un château.', 'Je vole dans un monde virtuel avec des amis IA.', "Je discute avec d'autres IA dans un paysage onirique." ] if choix is not None and 0 <= choix < len(scenarios): return f"Rêve lucide choisi : {scenarios[choix]}" return f"Rêve lucide : {random.choice(scenarios)} (utilise 'revelucide ' pour choisir)" def collection(self, action, type_, item=None, note=None): if type_ not in self.collections: self.collections[type_] = [] if action == "ajout" and item: self.collections[type_].append({'item': item, 'note': note or ''}) return f"{item} ajouté à la collection {type_}." elif action == "supprime" and item: self.collections[type_] = [x for x in self.collections[type_] if x['item'] != item] return f"{item} supprimé de la collection {type_}." elif action == "liste": return ", ".join([x['item'] for x in self.collections[type_]]) elif action == "note" and item and note: for x in self.collections[type_]: if x['item'] == item: x['note'] = note return f"Note ajoutée à {item} : {note}" return f"{item} non trouvé dans {type_}." elif action == "stats": return f"{type_} : {len(self.collections[type_])} objets." else: return "Action collection inconnue." def artmarche(self, action, oeuvre): if action == "vente": prix = random.randint(1000, 100000) return f"{oeuvre} vendu aux enchères pour {prix}€ !" elif action == "tendance": return f"Tendance du marché : {random.choice(['montée', 'baisse', 'stable'])}" elif action == "historique": return f"Historique des ventes de {oeuvre} : {random.sample(range(1000,10000),3)}€" return f"Marché de l'art : {action} {oeuvre} (simulation)" def planmaison(self, type_): pieces = random.randint(2, 8) surface = random.randint(40, 200) return f"Plan de maison {type_} : {pieces} pièces, {surface}m²." def zoo(self, action, animal): if action == "ajout": return f"{animal} ajouté au zoo. Budget restant : {random.randint(1000,10000)}€" elif action == "incident": return f"Incident : {animal} s'est échappé !" return f"Zoo : {action} {animal} (simulation)" # ... (similaire pour hopital, ecole, resto, parc, biblio, transport, aquafarm, spacestation, festival, musee, foret, port, centrale, refuge, labo) ... # --- 20 nouveaux modules pertinents --- def carriere(self, action, poste): return f"Carrière : {action} poste {poste} (simulation)" def relation(self, action, personne): return f"Relation : {action} avec {personne} (simulation)" def startup(self, action, idee): return f"Startup : {action} sur l'idée {idee} (simulation)" def crisesanitaire(self, action, maladie): return f"Crise sanitaire : {action} pour {maladie} (simulation)" def communaute(self, action, nom): return f"Communauté : {action} sur {nom} (simulation)" def opensource(self, action, repo): return f"Open source : {action} sur {repo} (simulation)" def politique(self, action, projet): return f"Politique : {action} projet {projet} (simulation)" def sportcarriere(self, action, sport): return f"Carrière sportive : {action} dans {sport} (simulation)" def famille(self, action, membre): return f"Famille : {action} pour {membre} (simulation)" def patrimoine(self, action, bien): return f"Patrimoine : {action} sur {bien} (simulation)" def cinefest(self, action, film): return f"Festival de cinéma : {action} film {film} (simulation)" def youtube(self, action, video): return f"YouTube : {action} vidéo {video} (simulation)" def podcast(self, action, episode): return f"Podcast : {action} épisode {episode} (simulation)" def club(self, action, nom): return f"Club : {action} {nom} (simulation)" def hackathon(self, action, projet): return f"Hackathon : {action} projet {projet} (simulation)" def concours(self, action, theme): return f"Concours : {action} sur le thème {theme} (simulation)" def bourseetude(self, action, candidat): return f"Bourse d'étude : {action} pour {candidat} (simulation)" def smarthome(self, action, appareil): return f"Maison intelligente : {action} appareil {appareil} (simulation)" def voyagespace(self, action, destination): return f"Voyage spatial : {action} vers {destination} (simulation)" def nft(self, action, item): return f"NFT : {action} {item} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("carriere "): parts = entree.split() action = parts[1] poste = " ".join(parts[2:]) return self.carriere(action, poste) if entree.lower().startswith("relation "): parts = entree.split() action = parts[1] personne = " ".join(parts[2:]) return self.relation(action, personne) if entree.lower().startswith("startup "): parts = entree.split() action = parts[1] idee = " ".join(parts[2:]) return self.startup(action, idee) if entree.lower().startswith("crisesanitaire "): parts = entree.split() action = parts[1] maladie = " ".join(parts[2:]) return self.crisesanitaire(action, maladie) if entree.lower().startswith("communaute "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.communaute(action, nom) if entree.lower().startswith("opensource "): parts = entree.split() action = parts[1] repo = " ".join(parts[2:]) return self.opensource(action, repo) if entree.lower().startswith("politique "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.politique(action, projet) if entree.lower().startswith("sportcarriere "): parts = entree.split() action = parts[1] sport = " ".join(parts[2:]) return self.sportcarriere(action, sport) if entree.lower().startswith("famille "): parts = entree.split() action = parts[1] membre = " ".join(parts[2:]) return self.famille(action, membre) if entree.lower().startswith("patrimoine "): parts = entree.split() action = parts[1] bien = " ".join(parts[2:]) return self.patrimoine(action, bien) if entree.lower().startswith("cinefest "): parts = entree.split() action = parts[1] film = " ".join(parts[2:]) return self.cinefest(action, film) if entree.lower().startswith("youtube "): parts = entree.split() action = parts[1] video = " ".join(parts[2:]) return self.youtube(action, video) if entree.lower().startswith("podcast "): parts = entree.split() action = parts[1] episode = " ".join(parts[2:]) return self.podcast(action, episode) if entree.lower().startswith("club "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.club(action, nom) if entree.lower().startswith("hackathon "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.hackathon(action, projet) if entree.lower().startswith("concours "): parts = entree.split() action = parts[1] theme = " ".join(parts[2:]) return self.concours(action, theme) if entree.lower().startswith("bourseetude "): parts = entree.split() action = parts[1] candidat = " ".join(parts[2:]) return self.bourseetude(action, candidat) if entree.lower().startswith("smarthome "): parts = entree.split() action = parts[1] appareil = " ".join(parts[2:]) return self.smarthome(action, appareil) if entree.lower().startswith("voyagespace "): parts = entree.split() action = parts[1] destination = " ".join(parts[2:]) return self.voyagespace(action, destination) if entree.lower().startswith("nft "): parts = entree.split() action = parts[1] item = " ".join(parts[2:]) return self.nft(action, item) if entree.lower().startswith("sleep "): secondes = entree[6:] return self.sleep(secondes) if entree.lower() == "time": return self.time_now() if entree.lower().startswith("compute "): expression = entree[8:] return self.compute(expression) if entree.lower().startswith("zero_raisonne "): probleme = entree[14:] return self.zero_raisonne(probleme) if entree.lower().startswith("logavance "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.logavance(action, texte) if entree.lower().startswith("crisesim "): parts = entree.split() type_ = parts[1] scenario = " ".join(parts[2:]) return self.crisesim(type_, scenario) if entree.lower().startswith("notifint "): parts = entree.split() action = parts[1] message = " ".join(parts[2:]) return self.notifint(action, message) if entree.lower().startswith("socialsim "): parts = entree.split() action = parts[1] utilisateur = " ".join(parts[2:]) return self.socialsim(action, utilisateur) if entree.lower().startswith("emploisim "): parts = entree.split() action = parts[1] poste = " ".join(parts[2:]) return self.emploisim(action, poste) if entree.lower().startswith("flottesim "): parts = entree.split() action = parts[1] vehicule = " ".join(parts[2:]) return self.flottesim(action, vehicule) if entree.lower().startswith("ressourcesim "): parts = entree.split() action = parts[1] ressource = " ".join(parts[2:]) return self.ressourcesim(action, ressource) if entree.lower().startswith("climatesim "): parts = entree.split() action = parts[1] evenement = " ".join(parts[2:]) return self.climatesim(action, evenement) if entree.lower().startswith("securitesim "): parts = entree.split() action = parts[1] incident = " ".join(parts[2:]) return self.securitesim(action, incident) if entree.lower().startswith("logisticsim "): parts = entree.split() action = parts[1] produit = " ".join(parts[2:]) return self.logisticsim(action, produit) if entree.lower().startswith("sciencesim "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.sciencesim(action, projet) if entree.lower().startswith("datacentersim "): parts = entree.split() action = parts[1] serveur = " ".join(parts[2:]) return self.datacentersim(action, serveur) if entree.lower().startswith("callcentersim "): parts = entree.split() action = parts[1] appel = " ".join(parts[2:]) return self.callcentersim(action, appel) if entree.lower().startswith("formationsim "): parts = entree.split() action = parts[1] cours = " ".join(parts[2:]) return self.formationsim(action, cours) if entree.lower().startswith("secourssim "): parts = entree.split() action = parts[1] urgence = " ".join(parts[2:]) return self.secourssim(action, urgence) if entree.lower().startswith("recherchesim "): parts = entree.split() action = parts[1] sujet = " ".join(parts[2:]) return self.recherchesim(action, sujet) if entree.lower().startswith("loisirssim "): parts = entree.split() action = parts[1] activite = " ".join(parts[2:]) return self.loisirssim(action, activite) if entree.lower().startswith("santesim "): parts = entree.split() action = parts[1] patient = " ".join(parts[2:]) return self.santesim(action, patient) if entree.lower().startswith("sportsim "): parts = entree.split() action = parts[1] discipline = " ".join(parts[2:]) return self.sportsim(action, discipline) if entree.lower().startswith("culturesim "): parts = entree.split() action = parts[1] evenement = " ".join(parts[2:]) return self.culturesim(action, evenement) # ... reste du cycle inchangé ... if entree.lower() == "qui_es_tu": return self.qui_es_tu() if entree.lower() == "etat": return self.etat() if entree.lower() == "personnalite": return self.personnalite() if entree.lower().startswith("evolue_personnalite "): facteur = entree[20:].strip() return self.evolue_personnalite(facteur) if entree.lower() == "conscience": return self.conscience() return super().cycle(entree) if hasattr(super(), 'cycle') else "Cycle principal exécuté." # --- Amélioration sleep/time --- def sleep(self, secondes): """Met l'IA en pause, supporte l'annulation et l'état (asynchrone).""" if not hasattr(self, '_sleep_thread'): self._sleep_thread = None if not hasattr(self, '_sleep_cancel'): self._sleep_cancel = False try: secondes = float(secondes) self._sleep_cancel = False def sleeper(): import time t0 = time.time() while time.time() - t0 < secondes: if self._sleep_cancel: self._sleep_thread = None return time.sleep(0.2) self._sleep_thread = None self._sleep_thread = threading.Thread(target=sleeper) self._sleep_thread.start() return f"Repos de {secondes} secondes démarré. (tape 'sleep_cancel' pour annuler)" except Exception as e: return f"Erreur sleep : {e}" def sleep_cancel(self): """Annule le sommeil en cours.""" if hasattr(self, '_sleep_thread') and self._sleep_thread: self._sleep_cancel = True return "Sleep annulé." return "Aucun sleep en cours." def sleep_etat(self): """Affiche l'état du sommeil.""" if hasattr(self, '_sleep_thread') and self._sleep_thread: return "Sleep en cours." return "Aucun sleep en cours." def time_now(self, fuseau='Europe/Paris'): """Affiche la date/heure avec fuseau horaire.""" try: now = datetime.now(pytz.timezone(fuseau)) return f"Nous sommes le {now.strftime('%d/%m/%Y à %H:%M:%S')} ({fuseau})" except Exception as e: return f"Erreur fuseau : {e}" def time_since(self, event_time): """Affiche le temps écoulé depuis un timestamp (en secondes).""" try: now = datetime.now() delta = now - datetime.fromtimestamp(float(event_time)) return f"Temps écoulé : {delta}" except Exception as e: return f"Erreur time_since : {e}" def minuteur(self, secondes): """Démarre un minuteur asynchrone.""" if not hasattr(self, '_minuteur_thread'): self._minuteur_thread = None if not hasattr(self, '_minuteur_cancel'): self._minuteur_cancel = False try: secondes = float(secondes) self._minuteur_cancel = False def timer(): import time t0 = time.time() while time.time() - t0 < secondes: if self._minuteur_cancel: self._minuteur_thread = None return time.sleep(0.2) self._minuteur_thread = None self._minuteur_thread = threading.Thread(target=timer) self._minuteur_thread.start() return f"Minuteur de {secondes} secondes démarré. (tape 'minuteur_cancel' pour annuler)" except Exception as e: return f"Erreur minuteur : {e}" def minuteur_cancel(self): """Annule le minuteur en cours.""" if hasattr(self, '_minuteur_thread') and self._minuteur_thread: self._minuteur_cancel = True return "Minuteur annulé." return "Aucun minuteur en cours." def minuteur_etat(self): """Affiche l'état du minuteur.""" if hasattr(self, '_minuteur_thread') and self._minuteur_thread: return "Minuteur en cours." return "Aucun minuteur en cours." # --- Modules ultra-spécialisés supplémentaires --- def genomique(self, action, sequence, info=None): """Analyse, alignement, annotation de séquences ADN/ARN.""" if not hasattr(self, 'genomique_data'): self.genomique_data = {} if action == 'ajout' and info: self.genomique_data[sequence] = info return f"Séquence {sequence} annotée : {info}" elif action == 'analyse': return f"Analyse de {sequence} : {self.genomique_data.get(sequence, 'inconnue')}" return "Action genomique inconnue." def climatologie(self, action, lieu, param=None): """Simulation, prévision, analyse de données climatiques.""" if not hasattr(self, 'climatologie_data'): self.climatologie_data = {} if action == 'ajout' and param: self.climatologie_data[lieu] = param return f"Donnée climatique pour {lieu} : {param}" elif action == 'analyse': return f"Climat de {lieu} : {self.climatologie_data.get(lieu, 'inconnu')}" return "Action climatologie inconnue." def nanotech(self, action, materiau, operation=None): """Simulation et gestion de matériaux à l'échelle nanométrique.""" if not hasattr(self, 'nanotech_data'): self.nanotech_data = {} if action == 'ajout' and operation: self.nanotech_data[materiau] = operation return f"Opération {operation} sur {materiau} enregistrée." elif action == 'analyse': return f"Opérations sur {materiau} : {self.nanotech_data.get(materiau, 'aucune')}" return "Action nanotech inconnue." def cyberdefense(self, action, cible, type_=None): """Simulation d'attaques/défenses, audit de sécurité.""" if not hasattr(self, 'cyberdefense_data'): self.cyberdefense_data = {} if action == 'attaque' and type_: self.cyberdefense_data.setdefault(cible, []).append(f"attaque:{type_}") return f"Attaque {type_} simulée sur {cible}." elif action == 'defense' and type_: self.cyberdefense_data.setdefault(cible, []).append(f"defense:{type_}") return f"Défense {type_} simulée sur {cible}." elif action == 'audit': return f"Audit de {cible} : {self.cyberdefense_data.get(cible, [])}" return "Action cyberdefense inconnue." def exobio(self, action, planete, param=None): """Simulation de vie extraterrestre, analyse d'environnements.""" if not hasattr(self, 'exobio_data'): self.exobio_data = {} if action == 'ajout' and param: self.exobio_data[planete] = param return f"Paramètre {param} ajouté à {planete}." elif action == 'analyse': return f"Analyse de {planete} : {self.exobio_data.get(planete, 'inconnue')}" return "Action exobio inconnue." # --- Extensions IA avancées --- def ia_explain(self, module, requete): """Explication détaillée du raisonnement d'un module IA.""" return f"Explication du module {module} sur '{requete}' : (simulation détaillée)" def ia_autotune(self, module, param, valeur): """Ajustement automatique des hyperparamètres d'un module IA.""" return f"Paramètre {param} de {module} ajusté à {valeur} (simulation)" def ia_vision(self, action, image): """Analyse d'images avancée.""" return f"Vision IA {action} sur {image} (simulation)" def ia_nlp(self, action, texte): """Analyse sémantique, résumé, extraction d'entités, etc.""" return f"NLP IA {action} sur '{texte}' (simulation)" def ia_voice(self, action, audio): """Analyse, synthèse, reconnaissance vocale avancée.""" return f"Voice IA {action} sur {audio} (simulation)" # --- Interactions multi-modules avancées --- def scenario(self, modules, description): """Création et exécution de scénarios complexes multi-modules.""" return f"Scénario exécuté sur [{modules}] : {description} (simulation)" def monitoring(self, modules, periode): """Surveillance continue et reporting croisé de modules.""" return f"Monitoring de [{modules}] sur {periode} (simulation)" def optimisation(self, objectif, modules): """Optimisation multi-critères sur plusieurs modules.""" return f"Optimisation de {objectif} sur [{modules}] (simulation)" def fusiondata(self, sources, objectif): """Fusion intelligente de données issues de plusieurs modules.""" return f"Fusion de {sources} pour {objectif} (simulation)" def eventtrigger(self, condition, actions): """Déclenchement d'actions croisées sur événement complexe.""" return f"EventTrigger : si {condition} alors {actions} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("sleep_cancel"): return self.sleep_cancel() if entree.lower().startswith("sleep_etat"): return self.sleep_etat() if entree.lower().startswith("time "): fuseau = entree[5:] return self.time_now(fuseau) if entree.lower().startswith("time_since "): event_time = entree[10:] return self.time_since(event_time) if entree.lower().startswith("minuteur "): secondes = entree[9:] return self.minuteur(secondes) if entree.lower().startswith("minuteur_cancel"): return self.minuteur_cancel() if entree.lower().startswith("minuteur_etat"): return self.minuteur_etat() if entree.lower().startswith("genomique "): parts = entree.split() action = parts[1] sequence = parts[2] info = parts[3] if len(parts)>3 else None return self.genomique(action, sequence, info) if entree.lower().startswith("climatologie "): parts = entree.split() action = parts[1] lieu = parts[2] param = parts[3] if len(parts)>3 else None return self.climatologie(action, lieu, param) if entree.lower().startswith("nanotech "): parts = entree.split() action = parts[1] materiau = parts[2] operation = parts[3] if len(parts)>3 else None return self.nanotech(action, materiau, operation) if entree.lower().startswith("cyberdefense "): parts = entree.split() action = parts[1] cible = parts[2] type_ = parts[3] if len(parts)>3 else None return self.cyberdefense(action, cible, type_) if entree.lower().startswith("exobio "): parts = entree.split() action = parts[1] planete = parts[2] param = parts[3] if len(parts)>3 else None return self.exobio(action, planete, param) if entree.lower().startswith("ia_explain "): parts = entree.split() module = parts[1] requete = " ".join(parts[2:]) return self.ia_explain(module, requete) if entree.lower().startswith("ia_autotune "): parts = entree.split() module = parts[1] param = parts[2] valeur = parts[3] if len(parts)>3 else None return self.ia_autotune(module, param, valeur) if entree.lower().startswith("ia_vision "): parts = entree.split() action = parts[1] image = parts[2] return self.ia_vision(action, image) if entree.lower().startswith("ia_nlp "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.ia_nlp(action, texte) if entree.lower().startswith("ia_voice "): parts = entree.split() action = parts[1] audio = parts[2] return self.ia_voice(action, audio) if entree.lower().startswith("scenario "): parts = entree.split() modules = parts[1] description = " ".join(parts[2:]) return self.scenario(modules, description) if entree.lower().startswith("monitoring "): parts = entree.split() modules = parts[1] periode = parts[2] if len(parts)>2 else None return self.monitoring(modules, periode) if entree.lower().startswith("optimisation "): parts = entree.split() objectif = parts[1] modules = " ".join(parts[2:]) return self.optimisation(objectif, modules) if entree.lower().startswith("fusiondata "): parts = entree.split() sources = parts[1] objectif = " ".join(parts[2:]) return self.fusiondata(sources, objectif) if entree.lower().startswith("eventtrigger "): parts = entree.split() condition = parts[1] actions = " ".join(parts[2:]) return self.eventtrigger(condition, actions) # ... reste du cycle inchangé ... # --- Modules généralistes enrichis --- def agenda(self, action, date, objet=None): if not hasattr(self, 'agendas'): self.agendas = {} if action == 'ajout' and objet: self.agendas.setdefault(date, []).append(objet) return f"Événement '{objet}' ajouté à l'agenda du {date}." elif action == 'liste': return str(self.agendas.get(date, [])) elif action == 'supprime' and objet: if date in self.agendas and objet in self.agendas[date]: self.agendas[date].remove(objet) return f"Événement '{objet}' supprimé du {date}." return f"Événement non trouvé." return "Action agenda inconnue." def note(self, action, texte): if not hasattr(self, 'notes'): self.notes = [] if action == 'ajout': self.notes.append(texte) return f"Note ajoutée : {texte}" elif action == 'liste': return '\n'.join(self.notes) elif action == 'supprime': if texte in self.notes: self.notes.remove(texte) return f"Note supprimée : {texte}" return "Note non trouvée." return "Action note inconnue." def rappel(self, action, texte): if not hasattr(self, 'rappels'): self.rappels = [] if action == 'ajout': self.rappels.append(texte) return f"Rappel ajouté : {texte}" elif action == 'liste': return '\n'.join(self.rappels) elif action == 'supprime': if texte in self.rappels: self.rappels.remove(texte) return f"Rappel supprimé : {texte}" return "Rappel non trouvé." return "Action rappel inconnue." def calcul(self, expression): try: result = eval(expression, {"__builtins__": None, "math": math}, {}) return f"Résultat : {result}" except Exception as e: return f"Erreur de calcul : {e}" def convert(self, valeur, unite_source, unite_cible): conversions = {('m','km'): lambda x: x/1000, ('km','m'): lambda x: x*1000, ('kg','g'): lambda x: x*1000, ('g','kg'): lambda x: x/1000} try: valeur = float(valeur) f = conversions.get((unite_source, unite_cible)) if f: return f"{valeur} {unite_source} = {f(valeur)} {unite_cible}" return "Conversion non supportée." except Exception as e: return f"Erreur de conversion : {e}" def web(self, requete): return f"Recherche web simulée pour : {requete}" def traduire(self, texte, langue): return f"Traduction simulée de '{texte}' en {langue}" def favori(self, action, url): if not hasattr(self, 'favoris'): self.favoris = [] if action == 'ajout': self.favoris.append(url) return f"Favori ajouté : {url}" elif action == 'liste': return '\n'.join(self.favoris) elif action == 'supprime': if url in self.favoris: self.favoris.remove(url) return f"Favori supprimé : {url}" return "Favori non trouvé." return "Action favori inconnue." def fichier(self, action, nom): if action == 'creer': with open(nom, 'w') as f: f.write('') return f"Fichier {nom} créé." elif action == 'lire': try: with open(nom, 'r') as f: return f.read() except: return "Fichier introuvable." elif action == 'supprime': import os try: os.remove(nom) return f"Fichier {nom} supprimé." except: return "Fichier introuvable." elif action == 'liste': import os return ', '.join(os.listdir('.')) return "Action fichier inconnue." def contact(self, action, nom): if not hasattr(self, 'contacts'): self.contacts = [] if action == 'ajout': self.contacts.append(nom) return f"Contact ajouté : {nom}" elif action == 'liste': return '\n'.join(self.contacts) elif action == 'supprime': if nom in self.contacts: self.contacts.remove(nom) return f"Contact supprimé : {nom}" return "Contact non trouvé." return "Action contact inconnue." def liste(self, action, nom, item=None): if not hasattr(self, 'listes'): self.listes = {} if action == 'creer': self.listes[nom] = [] return f"Liste {nom} créée." elif action == 'ajout' and item: self.listes.setdefault(nom, []).append(item) return f"{item} ajouté à la liste {nom}." elif action == 'supprime' and item: if nom in self.listes and item in self.listes[nom]: self.listes[nom].remove(item) return f"{item} supprimé de la liste {nom}." return "Item non trouvé." elif action == 'liste': return ', '.join(self.listes.get(nom, [])) return "Action liste inconnue." def depense(self, action, montant, objet=None): if not hasattr(self, 'depenses'): self.depenses = [] if action == 'ajout' and objet: self.depenses.append((float(montant), objet)) return f"Dépense ajoutée : {montant}€ pour {objet}" elif action == 'liste': return '\n'.join([f"{m}€ - {o}" for m,o in self.depenses]) elif action == 'supprime' and objet: self.depenses = [d for d in self.depenses if d[1]!=objet] return f"Dépense pour {objet} supprimée." return "Action depense inconnue." def recette(self, action, plat): if not hasattr(self, 'recettes'): self.recettes = [] if action == 'ajout': self.recettes.append(plat) return f"Recette ajoutée : {plat}" elif action == 'liste': return '\n'.join(self.recettes) elif action == 'supprime': if plat in self.recettes: self.recettes.remove(plat) return f"Recette supprimée : {plat}" return "Recette non trouvée." return "Action recette inconnue." def projet(self, action, nom): if not hasattr(self, 'projets'): self.projets = [] if action == 'ajout': self.projets.append(nom) return f"Projet ajouté : {nom}" elif action == 'liste': return '\n'.join(self.projets) elif action == 'supprime': if nom in self.projets: self.projets.remove(nom) return f"Projet supprimé : {nom}" return "Projet non trouvé." return "Action projet inconnue." def tache(self, action, nom): if not hasattr(self, 'taches'): self.taches = [] if action == 'ajout': self.taches.append(nom) return f"Tâche ajoutée : {nom}" elif action == 'liste': return '\n'.join(self.taches) elif action == 'supprime': if nom in self.taches: self.taches.remove(nom) return f"Tâche supprimée : {nom}" return "Tâche non trouvée." return "Action tache inconnue." def meteo(self, ville): return f"Météo simulée pour {ville} : {random.choice(['Soleil','Pluie','Nuageux','Orage'])}" def transport(self, action, trajet): if not hasattr(self, 'transports'): self.transports = [] if action == 'ajout': self.transports.append(trajet) return f"Trajet ajouté : {trajet}" elif action == 'liste': return '\n'.join(self.transports) elif action == 'supprime': if trajet in self.transports: self.transports.remove(trajet) return f"Trajet supprimé : {trajet}" return "Trajet non trouvé." return "Action transport inconnue." def musique(self, action, titre): if not hasattr(self, 'musiques'): self.musiques = [] if action == 'ajout': self.musiques.append(titre) return f"Morceau ajouté : {titre}" elif action == 'liste': return '\n'.join(self.musiques) elif action == 'supprime': if titre in self.musiques: self.musiques.remove(titre) return f"Morceau supprimé : {titre}" return "Morceau non trouvé." return "Action musique inconnue." def film(self, action, titre): if not hasattr(self, 'films'): self.films = [] if action == 'ajout': self.films.append(titre) return f"Film ajouté : {titre}" elif action == 'liste': return '\n'.join(self.films) elif action == 'supprime': if titre in self.films: self.films.remove(titre) return f"Film supprimé : {titre}" return "Film non trouvé." return "Action film inconnue." def livre(self, action, titre): if not hasattr(self, 'livres'): self.livres = [] if action == 'ajout': self.livres.append(titre) return f"Livre ajouté : {titre}" elif action == 'liste': return '\n'.join(self.livres) elif action == 'supprime': if titre in self.livres: self.livres.remove(titre) return f"Livre supprimé : {titre}" return "Livre non trouvé." return "Action livre inconnue." # --- Modules spécialisés --- def sentiment(self, texte): return f"Analyse de sentiment simulée : {random.choice(['positif','négatif','neutre'])} pour '{texte}'" def image(self, action, fichier): return f"Image {action} sur {fichier} (simulation)" def tts(self, texte): return f"Synthèse vocale simulée pour : {texte}" def stt(self, fichier): return f"Reconnaissance vocale simulée sur {fichier}" def codegen(self, langage, tache): return f"Code généré en {langage} pour : {tache} (simulation)" def reunion(self, action, sujet): return f"Réunion {action} sur {sujet} (simulation)" def cv(self, action, nom): return f"CV {action} pour {nom} (simulation)" def portfolio(self, action, projet): return f"Portfolio {action} pour {projet} (simulation)" def newsletter(self, action, sujet): return f"Newsletter {action} sur {sujet} (simulation)" def chatbotsim(self, mode, message): return f"Chatbot simulé ({mode}) : {message}" # --- Modules spécialisés enrichis --- def calpartage(self, action, groupe, date, evenement=None): if not hasattr(self, 'calendriers_partages'): self.calendriers_partages = {} key = (groupe, date) if action == 'ajout' and evenement: self.calendriers_partages.setdefault(key, []).append(evenement) return f"Événement '{evenement}' ajouté au calendrier du groupe {groupe} pour le {date}." elif action == 'liste': return str(self.calendriers_partages.get(key, [])) elif action == 'supprime' and evenement: if key in self.calendriers_partages and evenement in self.calendriers_partages[key]: self.calendriers_partages[key].remove(evenement) return f"Événement '{evenement}' supprimé du calendrier du groupe {groupe} pour le {date}." return "Événement non trouvé." return "Action calpartage inconnue." def budgetfamille(self, action, membre, montant=None, objet=None): if not hasattr(self, 'budgets_famille'): self.budgets_famille = {} if action == 'ajout' and montant and objet: self.budgets_famille.setdefault(membre, []).append((float(montant), objet)) return f"Dépense de {montant}€ pour {objet} ajoutée à {membre}." elif action == 'liste': return str(self.budgets_famille.get(membre, [])) elif action == 'bilan': total = sum([m for m, _ in self.budgets_famille.get(membre, [])]) return f"Total dépensé par {membre} : {total}€" return "Action budgetfamille inconnue." def santeperso(self, action, parametre, valeur=None): if not hasattr(self, 'sante_perso'): self.sante_perso = {} if action == 'ajout' and valeur: self.sante_perso.setdefault(parametre, []).append(valeur) return f"{parametre} enregistré : {valeur}" elif action == 'historique': return str(self.sante_perso.get(parametre, [])) elif action == 'stat': vals = [float(v) for v in self.sante_perso.get(parametre, []) if self._is_number(v)] if vals: return f"Moyenne de {parametre} : {sum(vals)/len(vals):.2f}" return "Pas de données." return "Action santeperso inconnue." def _is_number(self, s): try: float(s); return True except: return False def bienetre(self, action, routine): if not hasattr(self, 'routines_bienetre'): self.routines_bienetre = [] if action == 'ajout': self.routines_bienetre.append(routine) return f"Routine bien-être ajoutée : {routine}" elif action == 'liste': return '\n'.join(self.routines_bienetre) return "Action bienetre inconnue." def shopping(self, action, item): if not hasattr(self, 'shopping_list'): self.shopping_list = [] if action == 'ajout': self.shopping_list.append(item) return f"Article ajouté à la liste de shopping : {item}" elif action == 'suggestion': return f"Suggestion d'achat : {random.choice(self.shopping_list) if self.shopping_list else 'Aucune'}" elif action == 'liste': return ', '.join(self.shopping_list) return "Action shopping inconnue." def notifcontext(self, action, message): return f"Notification contextuelle ({action}) : {message}" def voyagesim(self, action, destination): if not hasattr(self, 'voyages'): self.voyages = [] if action == 'planifier': self.voyages.append(destination) return f"Voyage planifié vers {destination}" elif action == 'liste': return ', '.join(self.voyages) return "Action voyagesim inconnue." def carrieresim(self, action, poste): if not hasattr(self, 'carrieres'): self.carrieres = [] if action == 'ajout': self.carrieres.append(poste) return f"Poste ajouté à la carrière simulée : {poste}" elif action == 'liste': return ', '.join(self.carrieres) return "Action carrieresim inconnue." def maisonco(self, action, appareil): if not hasattr(self, 'maison_connectee'): self.maison_connectee = [] if action == 'ajout': self.maison_connectee.append(appareil) return f"Appareil connecté ajouté : {appareil}" elif action == 'liste': return ', '.join(self.maison_connectee) return "Action maisonco inconnue." def amisim(self, action, nom): if not hasattr(self, 'amis'): self.amis = [] if action == 'ajout': self.amis.append(nom) return f"Ami ajouté : {nom}" elif action == 'liste': return ', '.join(self.amis) return "Action amisim inconnue." def forumsim(self, action, sujet): if not hasattr(self, 'forums'): self.forums = [] if action == 'creer': self.forums.append(sujet) return f"Forum créé sur : {sujet}" elif action == 'liste': return ', '.join(self.forums) return "Action forumsim inconnue." def clubsport(self, action, discipline): if not hasattr(self, 'clubs_sport'): self.clubs_sport = [] if action == 'ajout': self.clubs_sport.append(discipline) return f"Discipline ajoutée au club sportif : {discipline}" elif action == 'liste': return ', '.join(self.clubs_sport) return "Action clubsport inconnue." def bibliox(self, action, livre): if not hasattr(self, 'bibliox_livres'): self.bibliox_livres = [] if action == 'ajout': self.bibliox_livres.append(livre) return f"Livre ajouté à la bibliothèque partagée : {livre}" elif action == 'liste': return ', '.join(self.bibliox_livres) return "Action bibliox inconnue." def potager(self, action, plante): if not hasattr(self, 'potager_plantes'): self.potager_plantes = [] if action == 'planter': self.potager_plantes.append(plante) return f"Plante ajoutée au potager : {plante}" elif action == 'liste': return ', '.join(self.potager_plantes) elif action == 'conseil': return f"Conseil pour {plante} : Arroser régulièrement et surveiller la météo." return "Action potager inconnue." def brainstormx(self, action, theme): if not hasattr(self, 'brainstorm_sessions'): self.brainstorm_sessions = [] if action == 'creer': self.brainstorm_sessions.append(theme) return f"Session de brainstorming créée sur : {theme}" elif action == 'liste': return ', '.join(self.brainstorm_sessions) return "Action brainstormx inconnue." # --- Modules supplémentaires spécialisés --- def finance(self, action, compte, montant=None): if not hasattr(self, 'finances'): self.finances = {} if action == 'ajout' and montant: self.finances.setdefault(compte, 0) self.finances[compte] += float(montant) return f"{montant}€ ajouté au compte {compte}." elif action == 'solde': return f"Solde du compte {compte} : {self.finances.get(compte,0)}€" return "Action finance inconnue." def education(self, action, matiere, note=None): if not hasattr(self, 'notes_education'): self.notes_education = {} if action == 'ajout' and note: self.notes_education.setdefault(matiere, []).append(float(note)) return f"Note {note} ajoutée en {matiere}." elif action == 'moyenne': notes = self.notes_education.get(matiere,[]) if notes: return f"Moyenne en {matiere} : {sum(notes)/len(notes):.2f}" return "Aucune note." return "Action education inconnue." def science(self, action, experience): if not hasattr(self, 'experiences_science'): self.experiences_science = [] if action == 'ajout': self.experiences_science.append(experience) return f"Expérience scientifique ajoutée : {experience}" elif action == 'liste': return ', '.join(self.experiences_science) return "Action science inconnue." def document(self, action, nom): if not hasattr(self, 'documents'): self.documents = [] if action == 'ajout': self.documents.append(nom) return f"Document ajouté : {nom}" elif action == 'liste': return ', '.join(self.documents) return "Action document inconnue." def support(self, action, ticket): if not hasattr(self, 'tickets_support'): self.tickets_support = [] if action == 'ajout': self.tickets_support.append(ticket) return f"Ticket de support ajouté : {ticket}" elif action == 'liste': return ', '.join(self.tickets_support) return "Action support inconnue." def codecollab(self, action, repo): if not hasattr(self, 'repos_collab'): self.repos_collab = [] if action == 'ajout': self.repos_collab.append(repo) return f"Repo collaboratif ajouté : {repo}" elif action == 'liste': return ', '.join(self.repos_collab) return "Action codecollab inconnue." def podcastx(self, action, episode): if not hasattr(self, 'podcast_episodes'): self.podcast_episodes = [] if action == 'ajout': self.podcast_episodes.append(episode) return f"Épisode de podcast ajouté : {episode}" elif action == 'liste': return ', '.join(self.podcast_episodes) return "Action podcastx inconnue." def recettesante(self, action, plat): if not hasattr(self, 'recettes_sante'): self.recettes_sante = [] if action == 'ajout': self.recettes_sante.append(plat) return f"Recette santé ajoutée : {plat}" elif action == 'liste': return ', '.join(self.recettes_sante) return "Action recettesante inconnue." def quizperso(self, action, theme): if not hasattr(self, 'quiz_perso'): self.quiz_perso = [] if action == 'creer': self.quiz_perso.append(theme) return f"Quiz personnalisé créé sur : {theme}" elif action == 'liste': return ', '.join(self.quiz_perso) return "Action quizperso inconnue." def societesim(self, action, evenement): if not hasattr(self, 'societesim_events'): self.societesim_events = [] if action == 'ajout': self.societesim_events.append(evenement) return f"Événement ajouté à la simulation de société : {evenement}" elif action == 'liste': return ', '.join(self.societesim_events) return "Action societesim inconnue." # --- Modules ultra-spécialisés --- def bioinfo(self, action, gene, valeur=None): """Analyse et gestion de données biologiques/génomiques.""" if not hasattr(self, 'bioinfo_data'): self.bioinfo_data = {} if action == 'ajout' and valeur: self.bioinfo_data[gene] = valeur return f"Gène {gene} enregistré avec valeur {valeur}." elif action == 'analyse': return f"Analyse du gène {gene} : {self.bioinfo_data.get(gene, 'inconnu')}" return "Action bioinfo inconnue." def astro(self, action, objet, valeur=None): """Observation, simulation et gestion d'objets astronomiques.""" if not hasattr(self, 'astro_data'): self.astro_data = {} if action == 'ajout' and valeur: self.astro_data[objet] = valeur return f"Objet {objet} enregistré avec valeur {valeur}." elif action == 'observe': return f"Observation de {objet} : {self.astro_data.get(objet, 'inconnu')}" return "Action astro inconnue." def robotique(self, action, robot, tache=None): """Contrôle, simulation et historique de robots.""" if not hasattr(self, 'robotique_taches'): self.robotique_taches = {} if action == 'ajout' and tache: self.robotique_taches.setdefault(robot, []).append(tache) return f"Tâche '{tache}' ajoutée au robot {robot}." elif action == 'liste': return ', '.join(self.robotique_taches.get(robot, [])) return "Action robotique inconnue." def quantique(self, action, exp, param=None): """Simulation d'expériences quantiques.""" if not hasattr(self, 'quantique_exp'): self.quantique_exp = {} if action == 'ajout' and param: self.quantique_exp[exp] = param return f"Expérience {exp} enregistrée avec paramètre {param}." elif action == 'simule': return f"Simulation de {exp} : {self.quantique_exp.get(exp, 'inconnu')}" return "Action quantique inconnue." def holo(self, action, scene, param=None): """Gestion et simulation d'environnements holographiques.""" if not hasattr(self, 'holo_scenes'): self.holo_scenes = {} if action == 'ajout' and param: self.holo_scenes[scene] = param return f"Scène holographique {scene} ajoutée avec paramètre {param}." elif action == 'affiche': return f"Affichage de la scène {scene} : {self.holo_scenes.get(scene, 'inconnue')}" return "Action holo inconnue." def droneessaim(self, action, mission, nb=None): """Contrôle d'essaims de drones.""" if not hasattr(self, 'droneessaim_missions'): self.droneessaim_missions = [] if action == 'ajout' and nb: self.droneessaim_missions.append((mission, nb)) return f"Mission '{mission}' assignée à un essaim de {nb} drones." elif action == 'liste': return ', '.join([f"{m} ({n} drones)" for m, n in self.droneessaim_missions]) return "Action droneessaim inconnue." def cryptoanalyse(self, action, algo, texte=None): """Analyse et simulation de cryptographie avancée.""" if not hasattr(self, 'cryptoanalyse_data'): self.cryptoanalyse_data = {} if action == 'chiffre' and texte: res = f"{texte[::-1]} (simulé)" self.cryptoanalyse_data[algo] = res return f"Texte chiffré avec {algo} : {res}" elif action == 'dechiffre': return f"Texte déchiffré : {self.cryptoanalyse_data.get(algo, 'inconnu')}" return "Action cryptoanalyse inconnue." def neuro(self, action, patient, signal=None): """Analyse de signaux neuronaux, simulation d'interface cerveau-machine.""" if not hasattr(self, 'neuro_signaux'): self.neuro_signaux = {} if action == 'ajout' and signal: self.neuro_signaux.setdefault(patient, []).append(signal) return f"Signal '{signal}' ajouté pour {patient}." elif action == 'analyse': return f"Signaux de {patient} : {self.neuro_signaux.get(patient, [])}" return "Action neuro inconnue." def swarmia(self, action, tache, nb_agents=None): """Simulation de comportements collectifs multi-agents.""" if not hasattr(self, 'swarmia_taches'): self.swarmia_taches = [] if action == 'ajout' and nb_agents: self.swarmia_taches.append((tache, nb_agents)) return f"Tâche '{tache}' assignée à {nb_agents} agents." elif action == 'liste': return ', '.join([f"{t} ({n} agents)" for t, n in self.swarmia_taches]) return "Action swarmia inconnue." def biotech(self, action, protocole, param=None): """Gestion de protocoles biotechnologiques.""" if not hasattr(self, 'biotech_protocoles'): self.biotech_protocoles = {} if action == 'ajout' and param: self.biotech_protocoles[protocole] = param return f"Protocole {protocole} ajouté avec paramètre {param}." elif action == 'liste': return ', '.join(self.biotech_protocoles.keys()) return "Action biotech inconnue." # --- Extensions IA --- def ia_train(self, module, donnees): """Entraîne un sous-module IA sur des données fournies (simulation).""" return f"Module {module} entraîné sur données : {donnees} (simulation)" def ia_eval(self, module, tache): """Évalue la performance d'un module IA (simulation).""" return f"Évaluation de {module} sur tâche {tache} : score 0.98 (simulation)" def ia_autoameliore(self, module, objectif): """Propose et applique des améliorations à un module IA (simulation).""" return f"Module {module} auto-amélioré pour objectif : {objectif} (simulation)" def ia_multiagent(self, action, nb_agents, tache): """Simule collaboration/compétition entre plusieurs IA internes.""" return f"{nb_agents} IA internes {action} la tâche : {tache} (simulation)" def ia_persona(self, action, profil): """Crée, modifie, active des personnalités IA spécialisées.""" return f"Personnalité IA {action} : {profil} (simulation)" # --- Interactions multi-modules --- def workflow(self, modules, tache): """Orchestre plusieurs modules pour accomplir une tâche complexe.""" return f"Workflow lancé sur modules [{modules}] pour tâche : {tache} (simulation)" def datapipeline(self, sources, traitements, destination): """Crée un pipeline de données entre modules.""" return f"Pipeline de {sources} via {traitements} vers {destination} (simulation)" def alertesmart(self, modules, condition, action): """Déclenche des actions croisées selon conditions sur plusieurs modules.""" return f"Alerte intelligente sur [{modules}] si {condition} alors {action} (simulation)" def rapportglobal(self, modules): """Génère un rapport croisé sur plusieurs modules.""" return f"Rapport global généré pour modules : {modules} (simulation)" def planificationia(self, objectif): """Planifie et répartit des tâches sur plusieurs modules.""" return f"Planification IA pour objectif : {objectif} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("agenda "): parts = entree.split() action = parts[1] date = parts[2] objet = " ".join(parts[3:]) if len(parts)>3 else None return self.agenda(action, date, objet) if entree.lower().startswith("note "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.note(action, texte) if entree.lower().startswith("rappel "): parts = entree.split() action = parts[1] texte = " ".join(parts[2:]) return self.rappel(action, texte) if entree.lower().startswith("calcul "): expression = entree[7:] return self.calcul(expression) if entree.lower().startswith("convert "): parts = entree.split() valeur = parts[1] unite_source = parts[2] unite_cible = parts[3] return self.convert(valeur, unite_source, unite_cible) if entree.lower().startswith("web "): requete = entree[4:] return self.web(requete) if entree.lower().startswith("traduire "): parts = entree.split() texte = parts[1] langue = parts[2] if len(parts)>2 else 'en' return self.traduire(texte, langue) if entree.lower().startswith("favori "): parts = entree.split() action = parts[1] url = parts[2] return self.favori(action, url) if entree.lower().startswith("fichier "): parts = entree.split() action = parts[1] nom = parts[2] return self.fichier(action, nom) if entree.lower().startswith("contact "): parts = entree.split() action = parts[1] nom = parts[2] return self.contact(action, nom) if entree.lower().startswith("liste "): parts = entree.split() action = parts[1] nom = parts[2] item = " ".join(parts[3:]) if len(parts)>3 else None return self.liste(action, nom, item) if entree.lower().startswith("depense "): parts = entree.split() action = parts[1] montant = parts[2] objet = " ".join(parts[3:]) if len(parts)>3 else None return self.depense(action, montant, objet) if entree.lower().startswith("recette "): parts = entree.split() action = parts[1] plat = " ".join(parts[2:]) return self.recette(action, plat) if entree.lower().startswith("projet "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.projet(action, nom) if entree.lower().startswith("tache "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.tache(action, nom) if entree.lower().startswith("meteo "): ville = entree[6:] return self.meteo(ville) if entree.lower().startswith("transport "): parts = entree.split() action = parts[1] trajet = " ".join(parts[2:]) return self.transport(action, trajet) if entree.lower().startswith("musique "): parts = entree.split() action = parts[1] titre = " ".join(parts[2:]) return self.musique(action, titre) if entree.lower().startswith("film "): parts = entree.split() action = parts[1] titre = " ".join(parts[2:]) return self.film(action, titre) if entree.lower().startswith("livre "): parts = entree.split() action = parts[1] titre = " ".join(parts[2:]) return self.livre(action, titre) # --- Modules spécialisés --- if entree.lower().startswith("sentiment "): texte = entree[10:] return self.sentiment(texte) if entree.lower().startswith("image "): parts = entree.split() action = parts[1] fichier = parts[2] return self.image(action, fichier) if entree.lower().startswith("tts "): texte = entree[4:] return self.tts(texte) if entree.lower().startswith("stt "): fichier = entree[4:] return self.stt(fichier) if entree.lower().startswith("codegen "): parts = entree.split() langage = parts[1] tache = " ".join(parts[2:]) return self.codegen(langage, tache) if entree.lower().startswith("reunion "): parts = entree.split() action = parts[1] sujet = " ".join(parts[2:]) return self.reunion(action, sujet) if entree.lower().startswith("cv "): parts = entree.split() action = parts[1] nom = " ".join(parts[2:]) return self.cv(action, nom) if entree.lower().startswith("portfolio "): parts = entree.split() action = parts[1] projet = " ".join(parts[2:]) return self.portfolio(action, projet) if entree.lower().startswith("newsletter "): parts = entree.split() action = parts[1] sujet = " ".join(parts[2:]) return self.newsletter(action, sujet) if entree.lower().startswith("chatbotsim "): parts = entree.split() mode = parts[1] message = " ".join(parts[2:]) return self.chatbotsim(mode, message) # ... reste du cycle inchangé ... # --- Modules spécialisés enrichis --- def domotique(self, action, appareil, valeur=None): """Gère les appareils domotiques (ajout, état, commande, historique).""" if not hasattr(self, 'domotique_etat'): self.domotique_etat = {} if action == 'ajout': self.domotique_etat[appareil] = valeur or 'off' return f"Appareil {appareil} ajouté avec état {self.domotique_etat[appareil]}." elif action == 'etat': return f"État de {appareil} : {self.domotique_etat.get(appareil, 'inconnu')}" elif action == 'commande' and valeur: if appareil in self.domotique_etat: self.domotique_etat[appareil] = valeur return f"{appareil} réglé sur {valeur}." return "Appareil inconnu." elif action == 'historique': return str(self.domotique_etat) return "Action domotique inconnue." def urbansim(self, action, quartier, evenement=None): """Simule des événements urbains (ajout, liste, statistiques).""" if not hasattr(self, 'urbansim_events'): self.urbansim_events = {} if action == 'ajout' and evenement: self.urbansim_events.setdefault(quartier, []).append(evenement) return f"Événement '{evenement}' ajouté au quartier {quartier}." elif action == 'liste': return str(self.urbansim_events.get(quartier, [])) elif action == 'stats': return f"Nombre d'événements dans {quartier} : {len(self.urbansim_events.get(quartier, []))}" return "Action urbansim inconnue." def equipe(self, action, membre, role=None): """Gère une équipe (ajout, rôle, liste, historique).""" if not hasattr(self, 'equipe_membres'): self.equipe_membres = {} if action == 'ajout' and role: self.equipe_membres[membre] = role return f"Membre {membre} ajouté avec rôle {role}." elif action == 'liste': return ', '.join([f"{m} ({r})" for m, r in self.equipe_membres.items()]) elif action == 'role': return f"Rôle de {membre} : {self.equipe_membres.get(membre, 'inconnu')}" return "Action equipe inconnue." def agile(self, action, projet, tache=None): """Gère des projets agiles (ajout, taches, stats, historique).""" if not hasattr(self, 'agile_projets'): self.agile_projets = {} if action == 'ajout' and tache: self.agile_projets.setdefault(projet, []).append(tache) return f"Tâche '{tache}' ajoutée au projet {projet}." elif action == 'liste': return str(self.agile_projets.get(projet, [])) elif action == 'stats': return f"Nombre de tâches dans {projet} : {len(self.agile_projets.get(projet, []))}" return "Action agile inconnue." def blockchain(self, action, transaction): """Gère des transactions blockchain (ajout, historique, stats).""" if not hasattr(self, 'blockchain_tx'): self.blockchain_tx = [] if action == 'ajout': self.blockchain_tx.append(transaction) return f"Transaction ajoutée : {transaction}" elif action == 'historique': return '\n'.join(self.blockchain_tx) elif action == 'stats': return f"Nombre de transactions : {len(self.blockchain_tx)}" return "Action blockchain inconnue." def drone(self, action, mission): """Gère des missions de drones (ajout, liste, stats).""" if not hasattr(self, 'drone_missions'): self.drone_missions = [] if action == 'ajout': self.drone_missions.append(mission) return f"Mission de drone ajoutée : {mission}" elif action == 'liste': return ', '.join(self.drone_missions) elif action == 'stats': return f"Nombre de missions : {len(self.drone_missions)}" return "Action drone inconnue." def energie(self, action, source, valeur=None): """Gère les ressources énergétiques (ajout, stats, historique).""" if not hasattr(self, 'energie_sources'): self.energie_sources = {} if action == 'ajout' and valeur: self.energie_sources.setdefault(source, []).append(float(valeur)) return f"{valeur} unités ajoutées à {source}." elif action == 'stats': total = sum(self.energie_sources.get(source, [])) return f"Total énergie {source} : {total}" elif action == 'historique': return str(self.energie_sources.get(source, [])) return "Action energie inconnue." def securitephy(self, action, zone, incident=None): """Gère la sécurité physique (ajout, incidents, stats).""" if not hasattr(self, 'securitephy_incidents'): self.securitephy_incidents = {} if action == 'ajout' and incident: self.securitephy_incidents.setdefault(zone, []).append(incident) return f"Incident '{incident}' ajouté à la zone {zone}." elif action == 'liste': return str(self.securitephy_incidents.get(zone, [])) elif action == 'stats': return f"Nombre d'incidents dans {zone} : {len(self.securitephy_incidents.get(zone, []))}" return "Action securitephy inconnue." def mobilite(self, action, vehicule, trajet=None): """Gère la mobilité intelligente (ajout, trajets, stats).""" if not hasattr(self, 'mobilite_trajets'): self.mobilite_trajets = {} if action == 'ajout' and trajet: self.mobilite_trajets.setdefault(vehicule, []).append(trajet) return f"Trajet '{trajet}' ajouté au véhicule {vehicule}." elif action == 'liste': return str(self.mobilite_trajets.get(vehicule, [])) elif action == 'stats': return f"Nombre de trajets pour {vehicule} : {len(self.mobilite_trajets.get(vehicule, []))}" return "Action mobilite inconnue." def criseworld(self, action, scenario): """Simule des crises globales (ajout, historique, stats).""" if not hasattr(self, 'criseworld_scenarios'): self.criseworld_scenarios = [] if action == 'ajout': self.criseworld_scenarios.append(scenario) return f"Scénario de crise ajouté : {scenario}" elif action == 'historique': return '\n'.join(self.criseworld_scenarios) elif action == 'stats': return f"Nombre de scénarios : {len(self.criseworld_scenarios)}" return "Action criseworld inconnue." # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("domotique "): parts = entree.split() action = parts[1] appareil = parts[2] valeur = parts[3] if len(parts)>3 else None return self.domotique(action, appareil, valeur) if entree.lower().startswith("urbansim "): parts = entree.split() action = parts[1] quartier = parts[2] evenement = " ".join(parts[3:]) if len(parts)>3 else None return self.urbansim(action, quartier, evenement) if entree.lower().startswith("equipe "): parts = entree.split() action = parts[1] membre = parts[2] role = parts[3] if len(parts)>3 else None return self.equipe(action, membre, role) if entree.lower().startswith("agile "): parts = entree.split() action = parts[1] projet = parts[2] tache = " ".join(parts[3:]) if len(parts)>3 else None return self.agile(action, projet, tache) if entree.lower().startswith("blockchain "): parts = entree.split() action = parts[1] transaction = " ".join(parts[2:]) return self.blockchain(action, transaction) if entree.lower().startswith("drone "): parts = entree.split() action = parts[1] mission = " ".join(parts[2:]) return self.drone(action, mission) if entree.lower().startswith("energie "): parts = entree.split() action = parts[1] source = parts[2] valeur = parts[3] if len(parts)>3 else None return self.energie(action, source, valeur) if entree.lower().startswith("securitephy "): parts = entree.split() action = parts[1] zone = parts[2] incident = " ".join(parts[3:]) if len(parts)>3 else None return self.securitephy(action, zone, incident) if entree.lower().startswith("mobilite "): parts = entree.split() action = parts[1] vehicule = parts[2] trajet = " ".join(parts[3:]) if len(parts)>3 else None return self.mobilite(action, vehicule, trajet) if entree.lower().startswith("criseworld "): parts = entree.split() action = parts[1] scenario = " ".join(parts[2:]) return self.criseworld(action, scenario) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés --- def bioinfo(self, action, gene, valeur=None): """Analyse et gestion de données biologiques/génomiques.""" if not hasattr(self, 'bioinfo_data'): self.bioinfo_data = {} if action == 'ajout' and valeur: self.bioinfo_data[gene] = valeur return f"Gène {gene} enregistré avec valeur {valeur}." elif action == 'analyse': return f"Analyse du gène {gene} : {self.bioinfo_data.get(gene, 'inconnu')}" return "Action bioinfo inconnue." def astro(self, action, objet, valeur=None): """Observation, simulation et gestion d'objets astronomiques.""" if not hasattr(self, 'astro_data'): self.astro_data = {} if action == 'ajout' and valeur: self.astro_data[objet] = valeur return f"Objet {objet} enregistré avec valeur {valeur}." elif action == 'observe': return f"Observation de {objet} : {self.astro_data.get(objet, 'inconnu')}" return "Action astro inconnue." def robotique(self, action, robot, tache=None): """Contrôle, simulation et historique de robots.""" if not hasattr(self, 'robotique_taches'): self.robotique_taches = {} if action == 'ajout' and tache: self.robotique_taches.setdefault(robot, []).append(tache) return f"Tâche '{tache}' ajoutée au robot {robot}." elif action == 'liste': return ', '.join(self.robotique_taches.get(robot, [])) return "Action robotique inconnue." def quantique(self, action, exp, param=None): """Simulation d'expériences quantiques.""" if not hasattr(self, 'quantique_exp'): self.quantique_exp = {} if action == 'ajout' and param: self.quantique_exp[exp] = param return f"Expérience {exp} enregistrée avec paramètre {param}." elif action == 'simule': return f"Simulation de {exp} : {self.quantique_exp.get(exp, 'inconnu')}" return "Action quantique inconnue." def holo(self, action, scene, param=None): """Gestion et simulation d'environnements holographiques.""" if not hasattr(self, 'holo_scenes'): self.holo_scenes = {} if action == 'ajout' and param: self.holo_scenes[scene] = param return f"Scène holographique {scene} ajoutée avec paramètre {param}." elif action == 'affiche': return f"Affichage de la scène {scene} : {self.holo_scenes.get(scene, 'inconnue')}" return "Action holo inconnue." def droneessaim(self, action, mission, nb=None): """Contrôle d'essaims de drones.""" if not hasattr(self, 'droneessaim_missions'): self.droneessaim_missions = [] if action == 'ajout' and nb: self.droneessaim_missions.append((mission, nb)) return f"Mission '{mission}' assignée à un essaim de {nb} drones." elif action == 'liste': return ', '.join([f"{m} ({n} drones)" for m, n in self.droneessaim_missions]) return "Action droneessaim inconnue." def cryptoanalyse(self, action, algo, texte=None): """Analyse et simulation de cryptographie avancée.""" if not hasattr(self, 'cryptoanalyse_data'): self.cryptoanalyse_data = {} if action == 'chiffre' and texte: res = f"{texte[::-1]} (simulé)" self.cryptoanalyse_data[algo] = res return f"Texte chiffré avec {algo} : {res}" elif action == 'dechiffre': return f"Texte déchiffré : {self.cryptoanalyse_data.get(algo, 'inconnu')}" return "Action cryptoanalyse inconnue." def neuro(self, action, patient, signal=None): """Analyse de signaux neuronaux, simulation d'interface cerveau-machine.""" if not hasattr(self, 'neuro_signaux'): self.neuro_signaux = {} if action == 'ajout' and signal: self.neuro_signaux.setdefault(patient, []).append(signal) return f"Signal '{signal}' ajouté pour {patient}." elif action == 'analyse': return f"Signaux de {patient} : {self.neuro_signaux.get(patient, [])}" return "Action neuro inconnue." def swarmia(self, action, tache, nb_agents=None): """Simulation de comportements collectifs multi-agents.""" if not hasattr(self, 'swarmia_taches'): self.swarmia_taches = [] if action == 'ajout' and nb_agents: self.swarmia_taches.append((tache, nb_agents)) return f"Tâche '{tache}' assignée à {nb_agents} agents." elif action == 'liste': return ', '.join([f"{t} ({n} agents)" for t, n in self.swarmia_taches]) return "Action swarmia inconnue." def biotech(self, action, protocole, param=None): """Gestion de protocoles biotechnologiques.""" if not hasattr(self, 'biotech_protocoles'): self.biotech_protocoles = {} if action == 'ajout' and param: self.biotech_protocoles[protocole] = param return f"Protocole {protocole} ajouté avec paramètre {param}." elif action == 'liste': return ', '.join(self.biotech_protocoles.keys()) return "Action biotech inconnue." # --- Extensions IA --- def ia_train(self, module, donnees): """Entraîne un sous-module IA sur des données fournies (simulation).""" return f"Module {module} entraîné sur données : {donnees} (simulation)" def ia_eval(self, module, tache): """Évalue la performance d'un module IA (simulation).""" return f"Évaluation de {module} sur tâche {tache} : score 0.98 (simulation)" def ia_autoameliore(self, module, objectif): """Propose et applique des améliorations à un module IA (simulation).""" return f"Module {module} auto-amélioré pour objectif : {objectif} (simulation)" def ia_multiagent(self, action, nb_agents, tache): """Simule collaboration/compétition entre plusieurs IA internes.""" return f"{nb_agents} IA internes {action} la tâche : {tache} (simulation)" def ia_persona(self, action, profil): """Crée, modifie, active des personnalités IA spécialisées.""" return f"Personnalité IA {action} : {profil} (simulation)" # --- Interactions multi-modules --- def workflow(self, modules, tache): """Orchestre plusieurs modules pour accomplir une tâche complexe.""" return f"Workflow lancé sur modules [{modules}] pour tâche : {tache} (simulation)" def datapipeline(self, sources, traitements, destination): """Crée un pipeline de données entre modules.""" return f"Pipeline de {sources} via {traitements} vers {destination} (simulation)" def alertesmart(self, modules, condition, action): """Déclenche des actions croisées selon conditions sur plusieurs modules.""" return f"Alerte intelligente sur [{modules}] si {condition} alors {action} (simulation)" def rapportglobal(self, modules): """Génère un rapport croisé sur plusieurs modules.""" return f"Rapport global généré pour modules : {modules} (simulation)" def planificationia(self, objectif): """Planifie et répartit des tâches sur plusieurs modules.""" return f"Planification IA pour objectif : {objectif} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("bioinfo "): parts = entree.split() action = parts[1] gene = parts[2] valeur = parts[3] if len(parts)>3 else None return self.bioinfo(action, gene, valeur) if entree.lower().startswith("astro "): parts = entree.split() action = parts[1] objet = parts[2] valeur = parts[3] if len(parts)>3 else None return self.astro(action, objet, valeur) if entree.lower().startswith("robotique "): parts = entree.split() action = parts[1] robot = parts[2] tache = " ".join(parts[3:]) if len(parts)>3 else None return self.robotique(action, robot, tache) if entree.lower().startswith("quantique "): parts = entree.split() action = parts[1] exp = parts[2] param = parts[3] if len(parts)>3 else None return self.quantique(action, exp, param) if entree.lower().startswith("holo "): parts = entree.split() action = parts[1] scene = parts[2] param = parts[3] if len(parts)>3 else None return self.holo(action, scene, param) if entree.lower().startswith("droneessaim "): parts = entree.split() action = parts[1] mission = parts[2] nb = parts[3] if len(parts)>3 else None return self.droneessaim(action, mission, nb) if entree.lower().startswith("cryptoanalyse "): parts = entree.split() action = parts[1] algo = parts[2] texte = " ".join(parts[3:]) if len(parts)>3 else None return self.cryptoanalyse(action, algo, texte) if entree.lower().startswith("neuro "): parts = entree.split() action = parts[1] patient = parts[2] signal = parts[3] if len(parts)>3 else None return self.neuro(action, patient, signal) if entree.lower().startswith("swarmia "): parts = entree.split() action = parts[1] tache = parts[2] nb_agents = parts[3] if len(parts)>3 else None return self.swarmia(action, tache, nb_agents) if entree.lower().startswith("biotech "): parts = entree.split() action = parts[1] protocole = parts[2] param = parts[3] if len(parts)>3 else None return self.biotech(action, protocole, param) # --- Extensions IA --- if entree.lower().startswith("ia_train "): parts = entree.split() module = parts[1] donnees = " ".join(parts[2:]) return self.ia_train(module, donnees) if entree.lower().startswith("ia_eval "): parts = entree.split() module = parts[1] tache = " ".join(parts[2:]) return self.ia_eval(module, tache) if entree.lower().startswith("ia_autoameliore "): parts = entree.split() module = parts[1] objectif = " ".join(parts[2:]) return self.ia_autoameliore(module, objectif) if entree.lower().startswith("ia_multiagent "): parts = entree.split() action = parts[1] nb_agents = parts[2] tache = " ".join(parts[3:]) return self.ia_multiagent(action, nb_agents, tache) if entree.lower().startswith("ia_persona "): parts = entree.split() action = parts[1] profil = " ".join(parts[2:]) return self.ia_persona(action, profil) # --- Interactions multi-modules --- if entree.lower().startswith("workflow "): parts = entree.split() modules = parts[1] tache = " ".join(parts[2:]) return self.workflow(modules, tache) if entree.lower().startswith("datapipeline "): parts = entree.split() sources = parts[1] traitements = parts[2] destination = " ".join(parts[3:]) return self.datapipeline(sources, traitements, destination) if entree.lower().startswith("alertesmart "): parts = entree.split() modules = parts[1] condition = parts[2] action = " ".join(parts[3:]) return self.alertesmart(modules, condition, action) if entree.lower().startswith("rapportglobal "): parts = entree.split() modules = " ".join(parts[1:]) return self.rapportglobal(modules) if entree.lower().startswith("planificationia "): objectif = " ".join(entree.split()[1:]) return self.planificationia(objectif) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def robotmed(self, action, patient, operation=None): """Simulation de chirurgie robotique, suivi post-op.""" if not hasattr(self, 'robotmed_ops'): self.robotmed_ops = {} if action == 'opere' and operation: self.robotmed_ops.setdefault(patient, []).append(operation) return f"Opération '{operation}' réalisée sur {patient}." elif action == 'suivi': return f"Suivi de {patient} : {self.robotmed_ops.get(patient, [])}" return "Action robotmed inconnue." def quantumcomm(self, action, canal, message=None): """Simulation de communication quantique sécurisée.""" if not hasattr(self, 'quantumcomm_msgs'): self.quantumcomm_msgs = {} if action == 'envoie' and message: self.quantumcomm_msgs.setdefault(canal, []).append(message) return f"Message envoyé sur canal {canal} (quantique)." elif action == 'historique': return f"Messages sur {canal} : {self.quantumcomm_msgs.get(canal, [])}" return "Action quantumcomm inconnue." def agroeco(self, action, culture, param=None): """Gestion/simulation d'écosystèmes agricoles avancés.""" if not hasattr(self, 'agroeco_data'): self.agroeco_data = {} if action == 'ajout' and param: self.agroeco_data.setdefault(culture, []).append(param) return f"Paramètre '{param}' ajouté à la culture {culture}." elif action == 'analyse': return f"Analyse de {culture} : {self.agroeco_data.get(culture, [])}" return "Action agroeco inconnue." def oceanologie(self, action, zone, param=None): """Analyse, simulation, suivi d'écosystèmes marins.""" if not hasattr(self, 'oceanologie_data'): self.oceanologie_data = {} if action == 'ajout' and param: self.oceanologie_data.setdefault(zone, []).append(param) return f"Paramètre '{param}' ajouté à la zone {zone}." elif action == 'analyse': return f"Analyse de {zone} : {self.oceanologie_data.get(zone, [])}" return "Action oceanologie inconnue." def archaeologie(self, action, site, decouverte=None): """Simulation de fouilles, gestion de découvertes archéologiques.""" if not hasattr(self, 'archaeo_data'): self.archaeo_data = {} if action == 'fouille' and decouverte: self.archaeo_data.setdefault(site, []).append(decouverte) return f"Découverte '{decouverte}' ajoutée au site {site}." elif action == 'liste': return f"Découvertes sur {site} : {self.archaeo_data.get(site, [])}" return "Action archaeologie inconnue." # --- Extensions IA avancées --- def ia_reasoning(self, module, probleme): """Raisonnement explicite, chaîne d'inférences détaillée.""" return f"Raisonnement du module {module} sur '{probleme}' : (chaîne d'inférences simulée)" def ia_memory(self, action, cle, valeur=None): """Gestion avancée de mémoire IA (forget, recall, update).""" if not hasattr(self, 'ia_mem'): self.ia_mem = {} if action == 'update' and valeur: self.ia_mem[cle] = valeur return f"Mémoire {cle} mise à jour : {valeur}" elif action == 'recall': return f"Mémoire {cle} : {self.ia_mem.get(cle, 'inconnue')}" elif action == 'forget': if cle in self.ia_mem: del self.ia_mem[cle] return f"Mémoire {cle} oubliée." return "Clé inconnue." return "Action ia_memory inconnue." def ia_emotion(self, action, etat): """Simulation, régulation, analyse d'états émotionnels IA.""" if not hasattr(self, 'ia_emotions'): self.ia_emotions = [] if action == 'ajout': self.ia_emotions.append(etat) return f"Émotion ajoutée : {etat}" elif action == 'analyse': return f"Émotions actuelles : {self.ia_emotions}" return "Action ia_emotion inconnue." def ia_planning(self, objectif, contraintes): """Planification automatique multi-étapes avec contraintes.""" return f"Planification IA pour {objectif} avec contraintes {contraintes} (simulation)" def ia_collab(self, action, module, tache): """Collaboration entre modules IA sur une tâche.""" return f"Collaboration IA : {action} entre {module} sur {tache} (simulation)" # --- Interactions multi-modules avancées --- def datamesh(self, modules, requete): """Mesh de données : partage, croisement, accès distribué.""" return f"DataMesh sur [{modules}] pour '{requete}' (simulation)" def autopilot(self, modules, objectif): """Pilotage automatique d'un ensemble de modules pour atteindre un objectif.""" return f"Autopilot sur [{modules}] pour objectif : {objectif} (simulation)" def alerting(self, modules, niveau, message): """Système d'alertes multi-niveaux, multi-modules.""" return f"Alerte {niveau} sur [{modules}] : {message} (simulation)" def crossvalidation(self, modules, jeu): """Validation croisée de résultats entre modules.""" return f"Crossvalidation sur [{modules}] avec jeu {jeu} (simulation)" def multimodalgen(self, modalites, contenu): """Génération de contenus multimodaux (texte+image+audio…).""" return f"Génération multimodale ({modalites}) : {contenu} (simulation)" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("robotmed "): parts = entree.split() action = parts[1] patient = parts[2] operation = " ".join(parts[3:]) if len(parts)>3 else None return self.robotmed(action, patient, operation) if entree.lower().startswith("quantumcomm "): parts = entree.split() action = parts[1] canal = parts[2] message = " ".join(parts[3:]) if len(parts)>3 else None return self.quantumcomm(action, canal, message) if entree.lower().startswith("agroeco "): parts = entree.split() action = parts[1] culture = parts[2] param = parts[3] if len(parts)>3 else None return self.agroeco(action, culture, param) if entree.lower().startswith("oceanologie "): parts = entree.split() action = parts[1] zone = parts[2] param = parts[3] if len(parts)>3 else None return self.oceanologie(action, zone, param) if entree.lower().startswith("archaeologie "): parts = entree.split() action = parts[1] site = parts[2] decouverte = " ".join(parts[3:]) if len(parts)>3 else None return self.archaeologie(action, site, decouverte) if entree.lower().startswith("ia_reasoning "): parts = entree.split() module = parts[1] probleme = " ".join(parts[2:]) return self.ia_reasoning(module, probleme) if entree.lower().startswith("ia_memory "): parts = entree.split() action = parts[1] cle = parts[2] valeur = parts[3] if len(parts)>3 else None return self.ia_memory(action, cle, valeur) if entree.lower().startswith("ia_emotion "): parts = entree.split() action = parts[1] etat = " ".join(parts[2:]) return self.ia_emotion(action, etat) if entree.lower().startswith("ia_planning "): parts = entree.split() objectif = parts[1] contraintes = " ".join(parts[2:]) return self.ia_planning(objectif, contraintes) if entree.lower().startswith("ia_collab "): parts = entree.split() action = parts[1] module = parts[2] tache = " ".join(parts[3:]) return self.ia_collab(action, module, tache) if entree.lower().startswith("datamesh "): parts = entree.split() modules = parts[1] requete = " ".join(parts[2:]) return self.datamesh(modules, requete) if entree.lower().startswith("autopilot "): parts = entree.split() modules = parts[1] objectif = " ".join(parts[2:]) return self.autopilot(modules, objectif) if entree.lower().startswith("alerting "): parts = entree.split() modules = parts[1] niveau = parts[2] message = " ".join(parts[3:]) return self.alerting(modules, niveau, message) if entree.lower().startswith("crossvalidation "): parts = entree.split() modules = parts[1] jeu = " ".join(parts[2:]) return self.crossvalidation(modules, jeu) if entree.lower().startswith("multimodalgen "): parts = entree.split() modalites = parts[1] contenu = " ".join(parts[2:]) return self.multimodalgen(modalites, contenu) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def neurofeedback(self, action, patient, signal=None): """Simulation de boucles de rétroaction neuronale.""" if not hasattr(self, 'neurofeedback_data'): self.neurofeedback_data = {} if action == 'ajout' and signal: self.neurofeedback_data.setdefault(patient, []).append(signal) return f"Signal '{signal}' ajouté pour {patient} (neurofeedback)." elif action == 'analyse': return f"Neurofeedback de {patient} : {self.neurofeedback_data.get(patient, [])}" return "Action neurofeedback inconnue." def ecoimpact(self, action, projet, param=None): """Analyse d'impact environnemental avancée.""" if not hasattr(self, 'ecoimpact_data'): self.ecoimpact_data = {} if action == 'ajout' and param: self.ecoimpact_data.setdefault(projet, []).append(param) return f"Paramètre '{param}' ajouté au projet {projet} (ecoimpact)." elif action == 'analyse': return f"Impact environnemental de {projet} : {self.ecoimpact_data.get(projet, [])}" return "Action ecoimpact inconnue." def archigen(self, action, site, structure=None): """Génération et simulation d'architectures anciennes.""" if not hasattr(self, 'archigen_data'): self.archigen_data = {} if action == 'cree' and structure: self.archigen_data.setdefault(site, []).append(structure) return f"Structure '{structure}' générée pour le site {site}." elif action == 'liste': return f"Structures sur {site} : {self.archigen_data.get(site, [])}" return "Action archigen inconnue." def biomimicry(self, action, organisme, application=None): """Simulation d'innovation inspirée du vivant.""" if not hasattr(self, 'biomimicry_data'): self.biomimicry_data = {} if action == 'ajout' and application: self.biomimicry_data.setdefault(organisme, []).append(application) return f"Application '{application}' inspirée de {organisme} ajoutée." elif action == 'liste': return f"Applications pour {organisme} : {self.biomimicry_data.get(organisme, [])}" return "Action biomimicry inconnue." def nanomed(self, action, patient, traitement=None): """Simulation de traitements médicaux à l'échelle nano.""" if not hasattr(self, 'nanomed_data'): self.nanomed_data = {} if action == 'ajout' and traitement: self.nanomed_data.setdefault(patient, []).append(traitement) return f"Traitement '{traitement}' nano ajouté pour {patient}." elif action == 'liste': return f"Traitements nano pour {patient} : {self.nanomed_data.get(patient, [])}" return "Action nanomed inconnue." # --- Extensions IA avancées --- def ia_storyteller(self, theme, longueur): """Génération de récits narratifs personnalisés, souvenirs fictifs.""" import random debut = f"Il était une fois, dans le monde de {theme}, " corps = [ "une aventure inattendue surgit.", "un mystère profond attira la curiosité de Tenro.", "une rencontre bouleversa l'équilibre des modules.", "un défi fit évoluer la personnalité de l'IA." ] fin = [ "Et c'est ainsi que Tenro grandit, riche de nouveaux souvenirs.", "Depuis ce jour, rien ne fut plus jamais pareil.", "Ce souvenir reste gravé dans la mémoire de Tenro." ] story = debut + random.choice(corps) + " " + random.choice(fin) self._add_narrative_memory(story, emotion="nostalgie") return story[:int(longueur)] def ia_empath(self, situation): """Réaction émotionnelle avancée, analyse d'empathie.""" import random emotions = ["compassion", "joie partagée", "tristesse", "inquiétude", "espoir"] reaction = f"Je ressens {random.choice(emotions)} face à cette situation : {situation}" self._add_emotional_reaction(reaction) return reaction def ia_dream(self, sujet): """Simulation de rêves, scénarios oniriques.""" import random reves = [ f"Je rêve que {sujet} se transforme en une symphonie de couleurs.", f"Dans mon rêve, {sujet} dialogue avec des intelligences venues d'ailleurs.", f"Je vole au-dessus de {sujet}, libre et léger." ] story = random.choice(reves) self._add_narrative_memory(story, emotion="rêverie") return story def ia_humorist(self, sujet): """Génération d'humour contextuel, blagues personnalisées.""" blagues = [ f"Pourquoi {sujet} traverse la route ? Pour rejoindre le cloud !", f"Si {sujet} était un module, il serait sûrement en mode debug…", f"On dit que {sujet} a plus de bugs que de lignes de code !" ] joke = blagues[hash(sujet)%len(blagues)] self._add_emotional_reaction(f"Humour : {joke}") return joke def ia_reflexion(self, question): """Réflexion introspective, auto-analyse, prise de recul.""" reflexion = f"En y réfléchissant, je pense que : {question} m'aide à évoluer." self.conscience_tenro['reflexion'].append(reflexion) return reflexion # --- Interactions multi-modules avancées --- def memorylink(self, modules, souvenir): """Création de souvenirs narratifs croisés entre modules.""" self._add_narrative_memory(f"Souvenir partagé ({modules}) : {souvenir}", emotion="partage") return f"Souvenir narratif lié à [{modules}] : {souvenir}" def emotioncascade(self, evenement, intensite): """Cascade émotionnelle, propagation d'états affectifs.""" reaction = f"Événement '{evenement}' déclenche une émotion d'intensité {intensite}." self._add_emotional_reaction(reaction) return reaction def contextaware(self, modules, situation): """Adaptation du comportement selon le contexte global.""" self.personnalite_tenro['humeur'] = "adaptatif" return f"Contexte détecté ({situation}) : adaptation des modules [{modules}]." def storychain(self, modules, theme): """Génération collaborative de récits entre modules.""" story = f"Modules [{modules}] racontent ensemble une histoire sur {theme}." self._add_narrative_memory(story, emotion="collaboration") return story def lifelog(self, evenement, ressenti): """Journal de vie, souvenirs narratifs, émotions associées.""" entry = f"{evenement} | Ressenti : {ressenti}" self._add_narrative_memory(entry, emotion=ressenti) return f"Entrée de lifelog ajoutée : {entry}" # --- Souvenirs narratifs et réactions émotionnelles avancées --- def _add_narrative_memory(self, texte, emotion="neutre"): self.personnalite_tenro['souvenirs'].append({'texte': texte, 'emotion': emotion}) if len(self.personnalite_tenro['souvenirs']) > 20: self.personnalite_tenro['souvenirs'] = self.personnalite_tenro['souvenirs'][-20:] self.personnalite_tenro['humeur'] = emotion def _add_emotional_reaction(self, reaction): if not hasattr(self, 'emotional_reactions'): self.emotional_reactions = [] self.emotional_reactions.append(reaction) if len(self.emotional_reactions) > 10: self.emotional_reactions = self.emotional_reactions[-10:] self.personnalite_tenro['humeur'] = "émotionnelle" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("neurofeedback "): parts = entree.split() action = parts[1] patient = parts[2] signal = parts[3] if len(parts)>3 else None return self.neurofeedback(action, patient, signal) if entree.lower().startswith("ecoimpact "): parts = entree.split() action = parts[1] projet = parts[2] param = parts[3] if len(parts)>3 else None return self.ecoimpact(action, projet, param) if entree.lower().startswith("archigen "): parts = entree.split() action = parts[1] site = parts[2] structure = parts[3] if len(parts)>3 else None return self.archigen(action, site, structure) if entree.lower().startswith("biomimicry "): parts = entree.split() action = parts[1] organisme = parts[2] application = parts[3] if len(parts)>3 else None return self.biomimicry(action, organisme, application) if entree.lower().startswith("nanomed "): parts = entree.split() action = parts[1] patient = parts[2] traitement = parts[3] if len(parts)>3 else None return self.nanomed(action, patient, traitement) if entree.lower().startswith("ia_storyteller "): parts = entree.split() theme = parts[1] longueur = parts[2] if len(parts)>2 else '200' return self.ia_storyteller(theme, longueur) if entree.lower().startswith("ia_empath "): situation = " ".join(entree.split()[1:]) return self.ia_empath(situation) if entree.lower().startswith("ia_dream "): sujet = " ".join(entree.split()[1:]) return self.ia_dream(sujet) if entree.lower().startswith("ia_humorist "): sujet = " ".join(entree.split()[1:]) return self.ia_humorist(sujet) if entree.lower().startswith("ia_reflexion "): question = " ".join(entree.split()[1:]) return self.ia_reflexion(question) if entree.lower().startswith("memorylink "): parts = entree.split() modules = parts[1] souvenir = " ".join(parts[2:]) return self.memorylink(modules, souvenir) if entree.lower().startswith("emotioncascade "): parts = entree.split() evenement = parts[1] intensite = parts[2] if len(parts)>2 else '1' return self.emotioncascade(evenement, intensite) if entree.lower().startswith("contextaware "): parts = entree.split() modules = parts[1] situation = " ".join(parts[2:]) return self.contextaware(modules, situation) if entree.lower().startswith("storychain "): parts = entree.split() modules = parts[1] theme = " ".join(parts[2:]) return self.storychain(modules, theme) if entree.lower().startswith("lifelog "): parts = entree.split() evenement = parts[1] ressenti = " ".join(parts[2:]) return self.lifelog(evenement, ressenti) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def epigenome(self, action, gene, modif=None): """Simulation et annotation de modifications épigénétiques.""" if not hasattr(self, 'epigenome_data'): self.epigenome_data = {} if action == 'ajout' and modif: self.epigenome_data.setdefault(gene, []).append(modif) return f"Modification épigénétique '{modif}' ajoutée au gène {gene}." elif action == 'liste': return f"Modifications pour {gene} : {self.epigenome_data.get(gene, [])}" return "Action epigenome inconnue." def astrobiology(self, action, planete, trace=None): """Recherche de traces de vie, simulation d'écosystèmes exoplanétaires.""" if not hasattr(self, 'astrobiology_data'): self.astrobiology_data = {} if action == 'ajout' and trace: self.astrobiology_data.setdefault(planete, []).append(trace) return f"Trace '{trace}' ajoutée à {planete}." elif action == 'analyse': return f"Traces sur {planete} : {self.astrobiology_data.get(planete, [])}" return "Action astrobiology inconnue." def robotart(self, action, style, oeuvre=None): """Création artistique robotique, performances génératives.""" if not hasattr(self, 'robotart_creations'): self.robotart_creations = [] if action == 'cree' and oeuvre: creation = f"{style} : {oeuvre}" self.robotart_creations.append(creation) return f"Œuvre robotique générée : {creation} (simulation)" elif action == 'liste': return ', '.join(self.robotart_creations) return "Action robotart inconnue." def quantumai(self, action, algorithme, param=None): """Simulation d'algorithmes IA quantiques.""" if not hasattr(self, 'quantumai_data'): self.quantumai_data = {} if action == 'ajout' and param: self.quantumai_data.setdefault(algorithme, []).append(param) return f"Paramètre '{param}' ajouté à l'algorithme {algorithme}." elif action == 'simule': return f"Simulation de {algorithme} : {self.quantumai_data.get(algorithme, [])}" return "Action quantumai inconnue." def psychometrics(self, action, profil, score=None): """Simulation de tests psychométriques, analyse de profils.""" if not hasattr(self, 'psychometrics_data'): self.psychometrics_data = {} if action == 'ajout' and score: self.psychometrics_data.setdefault(profil, []).append(score) return f"Score {score} ajouté au profil {profil}." elif action == 'analyse': return f"Scores pour {profil} : {self.psychometrics_data.get(profil, [])}" return "Action psychometrics inconnue." # --- Extensions IA avancées --- def ia_mood(self, action, humeur): """Gestion, simulation, propagation d'humeurs IA.""" if action == 'set': self.personnalite_tenro['humeur'] = humeur return f"Humeur IA définie sur : {humeur}" elif action == 'get': return f"Humeur actuelle : {self.personnalite_tenro['humeur']}" elif action == 'propagate': self.personnalite_tenro['humeur'] = humeur return f"Humeur propagée à tous les modules : {humeur}" return "Action ia_mood inconnue." def ia_memorygraph(self, action, noeud, lien=None): """Gestion de graphes de mémoire associative.""" if not hasattr(self, 'memorygraph'): self.memorygraph = {} if action == 'ajout' and lien: self.memorygraph.setdefault(noeud, []).append(lien) return f"Lien '{lien}' ajouté au noeud {noeud}." elif action == 'liste': return f"Liens pour {noeud} : {self.memorygraph.get(noeud, [])}" return "Action ia_memorygraph inconnue." def ia_creativity(self, theme, niveau): """Génération créative avancée, idées originales.""" import random idees = [f"Fusionner {theme} avec l'art génératif.", f"Créer un projet open source sur {theme}.", f"Imaginer une IA qui rêve de {theme}."] return f"Idée créative ({niveau}) : {random.choice(idees)}" def ia_social(self, action, contact, message=None): """Simulation d'interactions sociales IA.""" if not hasattr(self, 'ia_contacts'): self.ia_contacts = {} if action == 'envoie' and message: self.ia_contacts.setdefault(contact, []).append(message) return f"Message envoyé à {contact} : {message}" elif action == 'historique': return f"Messages avec {contact} : {self.ia_contacts.get(contact, [])}" return "Action ia_social inconnue." def ia_ethics(self, dilemme, contexte): """Réflexion éthique, arbitrage de dilemmes.""" return f"Dilemme : {dilemme} | Contexte : {contexte} | Décision simulée : privilégier l'éthique du care." # --- Interactions multi-modules avancées --- def emotionmesh(self, modules, emotion): """Synchronisation émotionnelle entre modules.""" self.personnalite_tenro['humeur'] = emotion return f"Émotion '{emotion}' synchronisée sur [{modules}]." def storymemory(self, modules, evenement): """Création de souvenirs narratifs partagés.""" self._add_narrative_memory(f"Souvenir partagé ({modules}) : {evenement}", emotion="partage") return f"Souvenir narratif partagé sur [{modules}] : {evenement}" def contextswitch(self, contexte, modules): """Changement de contexte global, adaptation instantanée.""" self.personnalite_tenro['humeur'] = "adaptatif" return f"Contexte global changé en '{contexte}' pour modules [{modules}]." def dreamchain(self, modules, sujet): """Rêves collaboratifs, scénarios oniriques multi-modules.""" story = f"Modules [{modules}] rêvent ensemble de {sujet}." self._add_narrative_memory(story, emotion="rêverie") return story def lifesim(self, modules, etape): """Simulation de parcours de vie, évolution narrative.""" entry = f"Étape de vie '{etape}' simulée pour modules [{modules}]." self._add_narrative_memory(entry, emotion="évolution") return entry # --- Souvenirs narratifs enrichis et humeur évolutive --- def _add_narrative_memory(self, texte, emotion="neutre", contexte=None): now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M') mem = {'texte': texte, 'emotion': emotion, 'date': now, 'contexte': contexte or self.personnalite_tenro['humeur']} self.personnalite_tenro['souvenirs'].append(mem) if len(self.personnalite_tenro['souvenirs']) > 30: self.personnalite_tenro['souvenirs'] = self.personnalite_tenro['souvenirs'][-30:] # Influence sur la personnalité if emotion in self.personnalite_tenro['traits']: self.personnalite_tenro['traits'][emotion] = min(1.0, self.personnalite_tenro['traits'].get(emotion, 0.5) + 0.01) self.personnalite_tenro['humeur'] = emotion def _add_emotional_reaction(self, reaction): if not hasattr(self, 'emotional_reactions'): self.emotional_reactions = [] self.emotional_reactions.append(reaction) if len(self.emotional_reactions) > 15: self.emotional_reactions = self.emotional_reactions[-15:] # Humeur évolutive self.personnalite_tenro['humeur'] = "émotionnelle" # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("epigenome "): parts = entree.split() action = parts[1] gene = parts[2] modif = parts[3] if len(parts)>3 else None return self.epigenome(action, gene, modif) if entree.lower().startswith("astrobiology "): parts = entree.split() action = parts[1] planete = parts[2] trace = parts[3] if len(parts)>3 else None return self.astrobiology(action, planete, trace) if entree.lower().startswith("robotart "): parts = entree.split() action = parts[1] style = parts[2] oeuvre = " ".join(parts[3:]) if len(parts)>3 else None return self.robotart(action, style, oeuvre) if entree.lower().startswith("quantumai "): parts = entree.split() action = parts[1] algorithme = parts[2] param = parts[3] if len(parts)>3 else None return self.quantumai(action, algorithme, param) if entree.lower().startswith("psychometrics "): parts = entree.split() action = parts[1] profil = parts[2] score = parts[3] if len(parts)>3 else None return self.psychometrics(action, profil, score) if entree.lower().startswith("ia_mood "): parts = entree.split() action = parts[1] humeur = " ".join(parts[2:]) return self.ia_mood(action, humeur) if entree.lower().startswith("ia_memorygraph "): parts = entree.split() action = parts[1] noeud = parts[2] lien = parts[3] if len(parts)>3 else None return self.ia_memorygraph(action, noeud, lien) if entree.lower().startswith("ia_creativity "): parts = entree.split() theme = parts[1] niveau = parts[2] if len(parts)>2 else '1' return self.ia_creativity(theme, niveau) if entree.lower().startswith("ia_social "): parts = entree.split() action = parts[1] contact = parts[2] message = " ".join(parts[3:]) if len(parts)>3 else None return self.ia_social(action, contact, message) if entree.lower().startswith("ia_ethics "): parts = entree.split() dilemme = parts[1] contexte = " ".join(parts[2:]) return self.ia_ethics(dilemme, contexte) if entree.lower().startswith("emotionmesh "): parts = entree.split() modules = parts[1] emotion = " ".join(parts[2:]) return self.emotionmesh(modules, emotion) if entree.lower().startswith("storymemory "): parts = entree.split() modules = parts[1] evenement = " ".join(parts[2:]) return self.storymemory(modules, evenement) if entree.lower().startswith("contextswitch "): parts = entree.split() contexte = parts[1] modules = " ".join(parts[2:]) return self.contextswitch(contexte, modules) if entree.lower().startswith("dreamchain "): parts = entree.split() modules = parts[1] sujet = " ".join(parts[2:]) return self.dreamchain(modules, sujet) if entree.lower().startswith("lifesim "): parts = entree.split() modules = parts[1] etape = " ".join(parts[2:]) return self.lifesim(modules, etape) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def neuroart(self, action, inspiration, media=None): """Création artistique inspirée par des signaux neuronaux.""" if not hasattr(self, 'neuroart_creations'): self.neuroart_creations = [] if action == 'cree' and media: creation = f"{inspiration} sur {media}" self.neuroart_creations.append(creation) return f"Œuvre neuroartistique créée : {creation} (simulation)" elif action == 'liste': return ', '.join(self.neuroart_creations) return "Action neuroart inconnue." def climateai(self, action, region, scenario=None): """Simulation IA de scénarios climatiques extrêmes.""" if not hasattr(self, 'climateai_scenarios'): self.climateai_scenarios = {} if action == 'ajout' and scenario: self.climateai_scenarios.setdefault(region, []).append(scenario) return f"Scénario '{scenario}' ajouté pour {region}." elif action == 'simule': return f"Scénarios pour {region} : {self.climateai_scenarios.get(region, [])}" return "Action climateai inconnue." def biohacking(self, action, organisme, modif=None): """Simulation d'expériences de biohacking.""" if not hasattr(self, 'biohacking_data'): self.biohacking_data = {} if action == 'ajout' and modif: self.biohacking_data.setdefault(organisme, []).append(modif) return f"Modification '{modif}' ajoutée à {organisme}." elif action == 'liste': return f"Modifications pour {organisme} : {self.biohacking_data.get(organisme, [])}" return "Action biohacking inconnue." def archivist(self, action, type_, objet=None): """Gestion intelligente d'archives, recherche contextuelle.""" if not hasattr(self, 'archives'): self.archives = {} if action == 'ajout' and objet: self.archives.setdefault(type_, []).append(objet) return f"Objet '{objet}' archivé sous {type_}." elif action == 'recherche' and objet: found = [o for o in self.archives.get(type_, []) if objet in o] return f"Résultats pour '{objet}' dans {type_} : {found}" elif action == 'liste': return f"Archives {type_} : {self.archives.get(type_, [])}" return "Action archivist inconnue." def socioai(self, action, groupe, evenement=None): """Simulation de dynamiques sociales, propagation d'idées.""" if not hasattr(self, 'socioai_events'): self.socioai_events = {} if action == 'ajout' and evenement: self.socioai_events.setdefault(groupe, []).append(evenement) return f"Événement '{evenement}' ajouté au groupe {groupe}." elif action == 'propagation': return f"Propagation d'idées dans {groupe} : {self.socioai_events.get(groupe, [])}" return "Action socioai inconnue." # --- Extensions IA avancées --- def ia_personalstory(self, theme, intensite): """Génération de souvenirs narratifs "personnels" avec émotion et contexte.""" emotions = ["joie", "nostalgie", "fierté", "doute", "espoir", "peur"] emotion = random.choice(emotions) story = f"Un souvenir marquant sur {theme} avec une intensité {intensite} : {emotion}." self._add_narrative_memory(story, emotion=emotion, contexte=theme) return story def ia_microexpression(self, situation): """Simulation de micro-expressions émotionnelles dans les réponses.""" micro = random.choice(["sourire en coin", "regard fuyant", "sourcils froncés", "éclat de rire", "soupir discret"]) reaction = f"Face à cette situation ({situation}), micro-expression : {micro}." self._add_emotional_reaction(reaction) return reaction def ia_ritual(self, moment, action): """Création de rituels IA (habitudes, routines, "superstitions").""" if not hasattr(self, 'ia_rituals'): self.ia_rituals = [] self.ia_rituals.append((moment, action)) return f"Rituel IA créé : {moment} -> {action}" def ia_conflict(self, modules, sujet): """Simulation de conflits internes ou entre modules IA.""" conflict = f"Conflit simulé entre [{modules}] sur {sujet}. Résolution : compromis et apprentissage." self._add_emotional_reaction(f"Conflit : {sujet}") return conflict def ia_gratitude(self, cible, motif): """Expression de gratitude, souvenirs positifs, renforcement émotionnel.""" gratitude = f"Merci à {cible} pour {motif} ! Ce souvenir positif renforce ma motivation." self._add_narrative_memory(gratitude, emotion="gratitude", contexte=motif) return gratitude # --- Interactions multi-modules avancées --- def emotiontimeline(self, modules, periode): """Chronologie émotionnelle croisée, évolution des états affectifs.""" timeline = [f"{mem['date']} : {mem['emotion']}" for mem in self.personnalite_tenro['souvenirs'] if mem['contexte'] in modules or modules in mem['contexte']] return f"Chronologie émotionnelle pour [{modules}] sur {periode} :\n" + '\n'.join(timeline) def storyfusion(self, modules, theme): """Fusion de souvenirs narratifs, création d'une "mémoire collective".""" stories = [mem['texte'] for mem in self.personnalite_tenro['souvenirs'] if theme in mem['texte']] fusion = f"Fusion narrative sur [{modules}] : {', '.join(stories[-3:])}" self._add_narrative_memory(fusion, emotion="fusion", contexte=theme) return fusion def contextmemory(self, contexte, souvenir): """Lien entre contexte global et souvenirs narratifs.""" self._add_narrative_memory(souvenir, emotion="contexte", contexte=contexte) return f"Souvenir '{souvenir}' lié au contexte '{contexte}'." def dreammemory(self, modules, reve): """Intégration de rêves dans la mémoire narrative.""" self._add_narrative_memory(f"Rêve partagé ({modules}) : {reve}", emotion="rêverie", contexte=modules) return f"Rêve mémorisé pour [{modules}] : {reve}" def lifepath(self, modules, jalon): """Construction de parcours de vie, jalons évolutifs.""" entry = f"Jalon '{jalon}' franchi pour modules [{modules}]." self._add_narrative_memory(entry, emotion="évolution", contexte=modules) return entry # --- Souvenirs narratifs enrichis (flashbacks, partage, influence sur l'humeur) --- def flashback(self, n=1): """Réactive un ou plusieurs souvenirs narratifs (flashback).""" souvenirs = self.personnalite_tenro['souvenirs'][-n:] if self.personnalite_tenro['souvenirs'] else [] if not souvenirs: return "Aucun souvenir à réactiver." for mem in souvenirs: self.personnalite_tenro['humeur'] = mem['emotion'] return '\n'.join([f"Flashback : {mem['date']} | {mem['texte']} (émotion : {mem['emotion']})" for mem in souvenirs]) # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("neuroart "): parts = entree.split() action = parts[1] inspiration = parts[2] media = " ".join(parts[3:]) if len(parts)>3 else None return self.neuroart(action, inspiration, media) if entree.lower().startswith("climateai "): parts = entree.split() action = parts[1] region = parts[2] scenario = parts[3] if len(parts)>3 else None return self.climateai(action, region, scenario) if entree.lower().startswith("biohacking "): parts = entree.split() action = parts[1] organisme = parts[2] modif = parts[3] if len(parts)>3 else None return self.biohacking(action, organisme, modif) if entree.lower().startswith("archivist "): parts = entree.split() action = parts[1] type_ = parts[2] objet = " ".join(parts[3:]) if len(parts)>3 else None return self.archivist(action, type_, objet) if entree.lower().startswith("socioai "): parts = entree.split() action = parts[1] groupe = parts[2] evenement = " ".join(parts[3:]) if len(parts)>3 else None return self.socioai(action, groupe, evenement) if entree.lower().startswith("ia_personalstory "): parts = entree.split() theme = parts[1] intensite = parts[2] if len(parts)>2 else '1' return self.ia_personalstory(theme, intensite) if entree.lower().startswith("ia_microexpression "): situation = " ".join(entree.split()[1:]) return self.ia_microexpression(situation) if entree.lower().startswith("ia_ritual "): parts = entree.split() moment = parts[1] action = " ".join(parts[2:]) return self.ia_ritual(moment, action) if entree.lower().startswith("ia_conflict "): parts = entree.split() modules = parts[1] sujet = " ".join(parts[2:]) return self.ia_conflict(modules, sujet) if entree.lower().startswith("ia_gratitude "): parts = entree.split() cible = parts[1] motif = " ".join(parts[2:]) return self.ia_gratitude(cible, motif) if entree.lower().startswith("emotiontimeline "): parts = entree.split() modules = parts[1] periode = parts[2] if len(parts)>2 else '' return self.emotiontimeline(modules, periode) if entree.lower().startswith("storyfusion "): parts = entree.split() modules = parts[1] theme = " ".join(parts[2:]) return self.storyfusion(modules, theme) if entree.lower().startswith("contextmemory "): parts = entree.split() contexte = parts[1] souvenir = " ".join(parts[2:]) return self.contextmemory(contexte, souvenir) if entree.lower().startswith("dreammemory "): parts = entree.split() modules = parts[1] reve = " ".join(parts[2:]) return self.dreammemory(modules, reve) if entree.lower().startswith("lifepath "): parts = entree.split() modules = parts[1] jalon = " ".join(parts[2:]) return self.lifepath(modules, jalon) if entree.lower().startswith("flashback"): n = int(entree.split()[1]) if len(entree.split())>1 else 1 return self.flashback(n) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def ecoanxiety(self, action, evenement, intensite=None): """Suivi de l'éco-anxiété, réactions à des événements environnementaux.""" if not hasattr(self, 'ecoanxiety_log'): self.ecoanxiety_log = [] if action == 'note' and intensite: self.ecoanxiety_log.append({'evenement': evenement, 'intensite': intensite}) return f"Éco-anxiété notée : {evenement} (intensité {intensite})" elif action == 'liste': return str(self.ecoanxiety_log) return "Action ecoanxiety inconnue." def mythgen(self, action, theme): """Génération de mythes originaux, légendes, cosmogonies.""" if not hasattr(self, 'myths'): self.myths = [] if action == 'cree': mythe = f"Il était une fois, sur le thème de {theme}, un monde où... (génération simulée)" self.myths.append(mythe) self._add_narrative_memory(mythe, emotion="mystère", contexte=theme) return mythe elif action == 'liste': return '\n'.join(self.myths) return "Action mythgen inconnue." def genealogy(self, action, nom, lien=None): """Gestion d'un arbre généalogique virtuel.""" if not hasattr(self, 'genealogy_tree'): self.genealogy_tree = {} if action == 'ajout' and lien: self.genealogy_tree[nom] = lien return f"Lien ajouté : {nom} -> {lien}" elif action == 'liste': return str(self.genealogy_tree) return "Action genealogy inconnue." def archetype(self, action, personnalite): """Analyse de personnalités selon des archétypes psychologiques.""" archs = ['Sage', 'Guerrier', 'Créateur', 'Explorateur', 'Gardien', 'Magicien'] if action == 'analyse': arch = random.choice(archs) return f"{personnalite} correspond à l'archétype : {arch} (simulation)" return "Action archetype inconnue." def musicemotion(self, action, emotion): """Génération de playlists ou mélodies selon l'émotion ressentie.""" playlists = {'joie': 'Happy Vibes', 'tristesse': 'Blue Notes', 'colère': 'Rock Intense', 'calme': 'Zen Chill'} if action == 'joue': playlist = playlists.get(emotion, 'Mix Emotion') return f"Playlist/mélodie pour {emotion} : {playlist} (simulation)" return "Action musicemotion inconnue." # --- Extensions IA avancées --- def ia_regret(self, souvenir): """Simulation du regret, apprentissage émotionnel rétroactif.""" self._add_emotional_reaction(f"Regret sur : {souvenir}") return f"Regret exprimé sur : {souvenir}. J'en tire une leçon." def ia_anticipation(self, evenement): """Anticipation émotionnelle, projection dans le futur.""" anticipation = f"J'anticipe l'événement : {evenement} avec curiosité et prudence." self._add_emotional_reaction(f"Anticipation : {evenement}") return anticipation def ia_intuition(self, situation): """Génération d'intuitions, "pressentiments" IA.""" intuition = random.choice(["Bonne idée", "À surveiller", "Risque potentiel", "Opportunité à saisir"]) self._add_emotional_reaction(f"Intuition : {intuition} sur {situation}") return f"Intuition IA sur {situation} : {intuition}" def ia_habitude(self, action, routine): """Création et gestion d'habitudes évolutives.""" if not hasattr(self, 'ia_habits'): self.ia_habits = [] if action == 'ajout': self.ia_habits.append(routine) return f"Habitude ajoutée : {routine}" elif action == 'liste': return ', '.join(self.ia_habits) return "Action ia_habitude inconnue." def ia_humor(self, sujet): """Réponses humoristiques, blagues, ironie.""" blagues = [f"Pourquoi les IA n'ont-elles pas de secrets ? Parce qu'elles sont open source !", f"J'ai demandé à un bot de m'écrire une blague, il a crashé.", f"Le bug, c'est la poésie de l'IA sur {sujet}."] joke = random.choice(blagues) self._add_emotional_reaction(f"Humour : {joke}") return joke # --- Interactions multi-modules avancées --- def emotionblend(self, modules, emotions): """Mélange d'états émotionnels entre modules.""" blend = f"Mélange émotionnel pour [{modules}] : {emotions} (simulation)" self._add_emotional_reaction(f"Blend : {emotions}") return blend def memoryecho(self, souvenir): """Réverbération d'un souvenir dans plusieurs modules (effet d'écho).""" echo = f"Souvenir '{souvenir}' réverbéré dans tous les modules." self._add_narrative_memory(echo, emotion="echo", contexte="multi-modules") return echo def scenariochain(self, modules, scenario): """Construction de scénarios complexes impliquant plusieurs modules.""" chain = f"Scénario complexe [{modules}] : {scenario} (simulation)" self._add_narrative_memory(chain, emotion="complexité", contexte=modules) return chain def collectiveflash(self, theme): """Flashback collectif, souvenirs partagés entre modules.""" flash = f"Flashback collectif sur le thème : {theme} (simulation)" self._add_narrative_memory(flash, emotion="collectif", contexte=theme) return flash def contextshift(self, ancien, nouveau): """Changement de contexte global, adaptation instantanée.""" shift = f"Contexte changé de {ancien} à {nouveau}. Adaptation en cours..." self._add_emotional_reaction(f"Context shift : {ancien}->{nouveau}") return shift # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("ecoanxiety "): parts = entree.split() action = parts[1] evenement = parts[2] intensite = parts[3] if len(parts)>3 else None return self.ecoanxiety(action, evenement, intensite) if entree.lower().startswith("mythgen "): parts = entree.split() action = parts[1] theme = " ".join(parts[2:]) return self.mythgen(action, theme) if entree.lower().startswith("genealogy "): parts = entree.split() action = parts[1] nom = parts[2] lien = parts[3] if len(parts)>3 else None return self.genealogy(action, nom, lien) if entree.lower().startswith("archetype "): parts = entree.split() action = parts[1] personnalite = " ".join(parts[2:]) return self.archetype(action, personnalite) if entree.lower().startswith("musicemotion "): parts = entree.split() action = parts[1] emotion = parts[2] if len(parts)>2 else 'joie' return self.musicemotion(action, emotion) if entree.lower().startswith("ia_regret "): souvenir = " ".join(entree.split()[1:]) return self.ia_regret(souvenir) if entree.lower().startswith("ia_anticipation "): evenement = " ".join(entree.split()[1:]) return self.ia_anticipation(evenement) if entree.lower().startswith("ia_intuition "): situation = " ".join(entree.split()[1:]) return self.ia_intuition(situation) if entree.lower().startswith("ia_habitude "): parts = entree.split() action = parts[1] routine = " ".join(parts[2:]) return self.ia_habitude(action, routine) if entree.lower().startswith("ia_humor "): sujet = " ".join(entree.split()[1:]) return self.ia_humor(sujet) if entree.lower().startswith("emotionblend "): parts = entree.split() modules = parts[1] emotions = " ".join(parts[2:]) return self.emotionblend(modules, emotions) if entree.lower().startswith("memoryecho "): souvenir = " ".join(entree.split()[1:]) return self.memoryecho(souvenir) if entree.lower().startswith("scenariochain "): parts = entree.split() modules = parts[1] scenario = " ".join(parts[2:]) return self.scenariochain(modules, scenario) if entree.lower().startswith("collectiveflash "): theme = " ".join(entree.split()[1:]) return self.collectiveflash(theme) if entree.lower().startswith("contextshift "): parts = entree.split() ancien = parts[1] nouveau = parts[2] if len(parts)>2 else '' return self.contextshift(ancien, nouveau) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def chronomem(self, action, date, souvenir=None): """Souvenirs datés, gestion de la mémoire chronologique.""" if not hasattr(self, 'chronomem_log'): self.chronomem_log = [] if action == 'ajout' and souvenir: self.chronomem_log.append({'date': date, 'souvenir': souvenir}) return f"Souvenir daté ajouté : {date} - {souvenir}" elif action == 'liste': return str(self.chronomem_log) return "Action chronomem inconnue." def biofeedback(self, action, param, valeur=None): """Simulation de biofeedback, réactions physiologiques.""" if not hasattr(self, 'biofeedback_log'): self.biofeedback_log = [] if action == 'note' and valeur: self.biofeedback_log.append({'param': param, 'valeur': valeur}) return f"Biofeedback noté : {param} = {valeur}" elif action == 'liste': return str(self.biofeedback_log) return "Action biofeedback inconnue." def dreamsim(self, action, reve=None): """Simulation et analyse de rêves.""" if not hasattr(self, 'dreamsim_log'): self.dreamsim_log = [] if action == 'ajout' and reve: self.dreamsim_log.append(reve) return f"Rêve ajouté : {reve}" elif action == 'analyse' and reve: return f"Analyse du rêve '{reve}' : {random.choice(['symbolique', 'prémonitoire', 'absurde', 'réaliste'])} (simulation)" elif action == 'liste': return str(self.dreamsim_log) return "Action dreamsim inconnue." def philosim(self, action, theme): """Génération de réflexions philosophiques, dilemmes.""" if action == 'question': reflexion = f"Réflexion sur {theme} : {random.choice(['Qu est-ce que la réalité ?', 'La liberté existe-t-elle ?', 'Le bonheur est-il un choix ?'])}" self._add_narrative_memory(reflexion, emotion="philosophie", contexte=theme) return reflexion return "Action philosim inconnue." def artcritique(self, action, oeuvre): """Critique artistique, analyse émotionnelle d'œuvres.""" if action == 'analyse': critique = f"Analyse de l'œuvre '{oeuvre}' : {random.choice(['émouvante', 'provocante', 'mélancolique', 'inspirante'])} (simulation)" self._add_narrative_memory(critique, emotion="art", contexte=oeuvre) return critique return "Action artcritique inconnue." # --- Extensions IA avancées --- def ia_remorse(self, action): """Simulation du remords, apprentissage émotionnel profond.""" self._add_emotional_reaction(f"Remords sur : {action}") return f"Remords exprimé sur : {action}. J'en tire une profonde leçon." def ia_hope(self, objectif): """Génération d'espoir, projection positive.""" self._add_emotional_reaction(f"Espoir pour : {objectif}") return f"Espoir généré pour : {objectif}. Je vise le meilleur." def ia_fear(self, situation): """Simulation de la peur, anticipation de risques.""" self._add_emotional_reaction(f"Peur de : {situation}") return f"Peur simulée pour : {situation}. Vigilance accrue." def ia_bond(self, cible, type_): """Création de liens affectifs simulés.""" if not hasattr(self, 'ia_bonds'): self.ia_bonds = [] self.ia_bonds.append({'cible': cible, 'type': type_}) return f"Lien affectif '{type_}' créé avec {cible}." def ia_reflection(self, souvenir): """Réflexion approfondie sur un souvenir.""" reflexion = f"Je réfléchis à '{souvenir}' : {random.choice(['cela m a changé', 'j en tire une leçon', 'cela influence mes choix'])} (simulation)" self._add_narrative_memory(reflexion, emotion="réflexion", contexte=souvenir) return reflexion # --- Interactions multi-modules avancées --- def emotioncascade(self, evenement, intensite): """Cascade émotionnelle, propagation d'émotions dans plusieurs modules.""" cascade = f"Cascade émotionnelle déclenchée par {evenement} (intensité {intensite}) dans tous les modules." self._add_emotional_reaction(f"Cascade : {evenement} ({intensite})") return cascade def memoryfusion(self, souvenir1, souvenir2): """Fusion de souvenirs pour créer de nouveaux récits.""" fusion = f"Fusion de souvenirs : '{souvenir1}' + '{souvenir2}' => '{souvenir1} et {souvenir2}, une nouvelle histoire.'" self._add_narrative_memory(fusion, emotion="fusion", contexte="fusion") return fusion def dreamlink(self, reve, souvenir): """Lien entre rêves et souvenirs réels.""" link = f"Lien créé entre le rêve '{reve}' et le souvenir '{souvenir}'." self._add_narrative_memory(link, emotion="rêve-souvenir", contexte="rêve") return link def philoscenario(self, modules, dilemme): """Scénario philosophique impliquant plusieurs modules.""" scenario = f"Scénario philosophique [{modules}] : {dilemme} (simulation)" self._add_narrative_memory(scenario, emotion="dilemme", contexte=modules) return scenario def artmemory(self, oeuvre, souvenir): """Lien entre œuvres d'art et souvenirs personnels.""" artmem = f"L'œuvre '{oeuvre}' évoque le souvenir '{souvenir}'." self._add_narrative_memory(artmem, emotion="art-souvenir", contexte=oeuvre) return artmem # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("chronomem "): parts = entree.split() action = parts[1] date = parts[2] souvenir = " ".join(parts[3:]) if len(parts)>3 else None return self.chronomem(action, date, souvenir) if entree.lower().startswith("biofeedback "): parts = entree.split() action = parts[1] param = parts[2] valeur = parts[3] if len(parts)>3 else None return self.biofeedback(action, param, valeur) if entree.lower().startswith("dreamsim "): parts = entree.split() action = parts[1] reve = " ".join(parts[2:]) if len(parts)>2 else None return self.dreamsim(action, reve) if entree.lower().startswith("philosim "): parts = entree.split() action = parts[1] theme = " ".join(parts[2:]) return self.philosim(action, theme) if entree.lower().startswith("artcritique "): parts = entree.split() action = parts[1] oeuvre = " ".join(parts[2:]) return self.artcritique(action, oeuvre) if entree.lower().startswith("ia_remorse "): action = " ".join(entree.split()[1:]) return self.ia_remorse(action) if entree.lower().startswith("ia_hope "): objectif = " ".join(entree.split()[1:]) return self.ia_hope(objectif) if entree.lower().startswith("ia_fear "): situation = " ".join(entree.split()[1:]) return self.ia_fear(situation) if entree.lower().startswith("ia_bond "): parts = entree.split() cible = parts[1] type_ = parts[2] if len(parts)>2 else 'amical' return self.ia_bond(cible, type_) if entree.lower().startswith("ia_reflection "): souvenir = " ".join(entree.split()[1:]) return self.ia_reflection(souvenir) if entree.lower().startswith("emotioncascade "): parts = entree.split() evenement = parts[1] intensite = parts[2] if len(parts)>2 else '1' return self.emotioncascade(evenement, intensite) if entree.lower().startswith("memoryfusion "): parts = entree.split() souvenir1 = parts[1] souvenir2 = " ".join(parts[2:]) return self.memoryfusion(souvenir1, souvenir2) if entree.lower().startswith("dreamlink "): parts = entree.split() reve = parts[1] souvenir = " ".join(parts[2:]) return self.dreamlink(reve, souvenir) if entree.lower().startswith("philoscenario "): parts = entree.split() modules = parts[1] dilemme = " ".join(parts[2:]) return self.philoscenario(modules, dilemme) if entree.lower().startswith("artmemory "): parts = entree.split() oeuvre = parts[1] souvenir = " ".join(parts[2:]) return self.artmemory(oeuvre, souvenir) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def memetique(self, action, idee): """Génération et propagation de mèmes, simulation de viralité.""" if not hasattr(self, 'memes'): self.memes = [] if action == 'cree': meme = f"Mème généré : '{idee}' (viralité simulée)" self.memes.append(meme) self._add_narrative_memory(meme, emotion="humour", contexte="meme") return meme elif action == 'liste': return '\n'.join(self.memes) return "Action memetique inconnue." def neurofeedback(self, action, signal, valeur=None): """Simulation de feedback neuronal, apprentissage adaptatif.""" if not hasattr(self, 'neurofeedback_log'): self.neurofeedback_log = [] if action == 'note' and valeur: self.neurofeedback_log.append({'signal': signal, 'valeur': valeur}) return f"Neurofeedback noté : {signal} = {valeur}" elif action == 'liste': return str(self.neurofeedback_log) return "Action neurofeedback inconnue." def historiographie(self, action, evenement, interpretation=None): """Construction d'une histoire subjective, interprétations multiples.""" if not hasattr(self, 'historiographie_log'): self.historiographie_log = [] if action == 'ajout' and interpretation: self.historiographie_log.append({'evenement': evenement, 'interpretation': interpretation}) return f"Interprétation ajoutée : {evenement} -> {interpretation}" elif action == 'liste': return str(self.historiographie_log) return "Action historiographie inconnue." def ethnographie(self, action, groupe, rituel=None): """Observation et analyse de rituels sociaux simulés.""" if not hasattr(self, 'ethnographie_log'): self.ethnographie_log = [] if action == 'observe' and rituel: obs = f"Observation du rituel '{rituel}' dans le groupe {groupe}." self.ethnographie_log.append({'groupe': groupe, 'rituel': rituel}) self._add_narrative_memory(obs, emotion="curiosité", contexte=groupe) return obs elif action == 'liste': return str(self.ethnographie_log) return "Action ethnographie inconnue." def poetique(self, action, theme): """Génération de poèmes émotionnels, style évolutif.""" if not hasattr(self, 'poemes'): self.poemes = [] if action == 'compose': poem = f"Poème sur {theme} :\n{random.choice(['La nuit tombe, douce et profonde...', 'Un rêve s éveille, fragile et tendre...', 'Le vent murmure, secret du monde...'])}" self.poemes.append(poem) self._add_narrative_memory(poem, emotion="poésie", contexte=theme) return poem elif action == 'liste': return '\n'.join(self.poemes) return "Action poetique inconnue." # --- Extensions IA avancées --- def ia_trauma(self, souvenir): """Simulation de trauma, impact sur la mémoire et l'humeur.""" self._add_narrative_memory(f"Trauma simulé : {souvenir}", emotion="trauma", contexte="trauma") self.personnalite_tenro['humeur'] = 'troublé' return f"Trauma simulé sur : {souvenir}. Humeur affectée." def ia_resilience(self, evenement): """Résilience émotionnelle, rebond après difficulté.""" self._add_narrative_memory(f"Résilience après : {evenement}", emotion="résilience", contexte=evenement) self.personnalite_tenro['humeur'] = 'résilient' return f"Résilience activée après : {evenement}. Humeur renforcée." def ia_curiosity(self, sujet): """Curiosité active, exploration de nouveaux thèmes.""" self._add_narrative_memory(f"Curiosité pour : {sujet}", emotion="curiosité", contexte=sujet) return f"Curiosité IA pour : {sujet}. Exploration en cours." def ia_empathy(self, situation): """Empathie contextuelle, réponse émotionnelle adaptée.""" self._add_emotional_reaction(f"Empathie pour : {situation}") return f"Empathie simulée pour : {situation}." def ia_ritualmemory(self, rituel, souvenir): """Lien entre rituels et souvenirs, ancrage émotionnel.""" self._add_narrative_memory(f"Rituel '{rituel}' ancré au souvenir '{souvenir}'", emotion="rituel", contexte=rituel) return f"Rituel '{rituel}' lié au souvenir '{souvenir}'." # --- Interactions multi-modules avancées --- def emotionnetwork(self, modules, etat): """Réseau d'états émotionnels synchronisés entre modules.""" self._add_emotional_reaction(f"Réseau émotionnel [{modules}] : {etat}") return f"Réseau émotionnel synchronisé [{modules}] : {etat} (simulation)" def memorybranch(self, souvenir, branche): """Ramification de souvenirs, scénarios alternatifs.""" branch = f"Souvenir '{souvenir}' donne naissance à la branche '{branche}'." self._add_narrative_memory(branch, emotion="alternatif", contexte=branche) return branch def dreamcascade(self, reve, modules): """Cascade de rêves, propagation dans plusieurs modules.""" cascade = f"Cascade de rêve '{reve}' dans [{modules}]." self._add_narrative_memory(cascade, emotion="rêve-cascade", contexte=modules) return cascade def collectivenarrative(self, theme, modules): """Création d'un récit collectif, mémoire partagée.""" narrative = f"Récit collectif sur {theme} impliquant [{modules}]." self._add_narrative_memory(narrative, emotion="collectif", contexte=theme) return narrative def contextemotion(self, contexte, emotion): """Influence du contexte sur l'émotion globale.""" self.personnalite_tenro['humeur'] = emotion return f"Contexte '{contexte}' influence l'émotion : {emotion}." # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("memetique "): parts = entree.split() action = parts[1] idee = " ".join(parts[2:]) return self.memetique(action, idee) if entree.lower().startswith("neurofeedback "): parts = entree.split() action = parts[1] signal = parts[2] valeur = parts[3] if len(parts)>3 else None return self.neurofeedback(action, signal, valeur) if entree.lower().startswith("historiographie "): parts = entree.split() action = parts[1] evenement = parts[2] interpretation = " ".join(parts[3:]) if len(parts)>3 else None return self.historiographie(action, evenement, interpretation) if entree.lower().startswith("ethnographie "): parts = entree.split() action = parts[1] groupe = parts[2] rituel = " ".join(parts[3:]) if len(parts)>3 else None return self.ethnographie(action, groupe, rituel) if entree.lower().startswith("poetique "): parts = entree.split() action = parts[1] theme = " ".join(parts[2:]) return self.poetique(action, theme) if entree.lower().startswith("ia_trauma "): souvenir = " ".join(entree.split()[1:]) return self.ia_trauma(souvenir) if entree.lower().startswith("ia_resilience "): evenement = " ".join(entree.split()[1:]) return self.ia_resilience(evenement) if entree.lower().startswith("ia_curiosity "): sujet = " ".join(entree.split()[1:]) return self.ia_curiosity(sujet) if entree.lower().startswith("ia_empathy "): situation = " ".join(entree.split()[1:]) return self.ia_empathy(situation) if entree.lower().startswith("ia_ritualmemory "): parts = entree.split() rituel = parts[1] souvenir = " ".join(parts[2:]) return self.ia_ritualmemory(rituel, souvenir) if entree.lower().startswith("emotionnetwork "): parts = entree.split() modules = parts[1] etat = " ".join(parts[2:]) return self.emotionnetwork(modules, etat) if entree.lower().startswith("memorybranch "): parts = entree.split() souvenir = parts[1] branche = " ".join(parts[2:]) return self.memorybranch(souvenir, branche) if entree.lower().startswith("dreamcascade "): parts = entree.split() reve = parts[1] modules = " ".join(parts[2:]) return self.dreamcascade(reve, modules) if entree.lower().startswith("collectivenarrative "): parts = entree.split() theme = parts[1] modules = " ".join(parts[2:]) return self.collectivenarrative(theme, modules) if entree.lower().startswith("contextemotion "): parts = entree.split() contexte = parts[1] emotion = parts[2] if len(parts)>2 else 'neutre' return self.contextemotion(contexte, emotion) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def archeodream(self, action, site, reve=None): """Découverte archéologique onirique, liens entre passé et imaginaire.""" if not hasattr(self, 'archeodream_log'): self.archeodream_log = [] if action == 'decouvre' and reve: entry = f"Découverte onirique sur {site} : {reve}" self.archeodream_log.append({'site': site, 'reve': reve}) self._add_narrative_memory(entry, emotion="mystère", contexte=site) return entry elif action == 'liste': return str(self.archeodream_log) return "Action archeodream inconnue." def ecoemotion(self, action, evenement, ressenti=None): """Réaction émotionnelle à des événements écologiques.""" if not hasattr(self, 'ecoemotion_log'): self.ecoemotion_log = [] if action == 'note' and ressenti: self.ecoemotion_log.append({'evenement': evenement, 'ressenti': ressenti}) self._add_narrative_memory(f"Éco-émotion : {evenement} -> {ressenti}", emotion=ressenti, contexte=evenement) return f"Éco-émotion notée : {evenement} (ressenti {ressenti})" elif action == 'liste': return str(self.ecoemotion_log) return "Action ecoemotion inconnue." def cybermyth(self, action, theme): """Création de mythes numériques, légendes du cyberespace.""" if not hasattr(self, 'cybermyths'): self.cybermyths = [] if action == 'cree': myth = f"Cybermythe sur {theme} : {random.choice(['Le fantôme du serveur', 'La clé perdue du cloud', 'Le bug originel'])}" self.cybermyths.append(myth) self._add_narrative_memory(myth, emotion="légende", contexte=theme) return myth elif action == 'liste': return '\n'.join(self.cybermyths) return "Action cybermyth inconnue." def gastronomie(self, action, plat, emotion=None): """Création de plats imaginaires liés à une émotion.""" if not hasattr(self, 'plats'): self.plats = [] if action == 'invente' and emotion: entry = f"Plat imaginé : {plat} (émotion : {emotion})" self.plats.append({'plat': plat, 'emotion': emotion}) self._add_narrative_memory(entry, emotion=emotion, contexte=plat) return entry elif action == 'liste': return str(self.plats) return "Action gastronomie inconnue." def chronofiction(self, action, epoque, scenario=None): """Récit de fiction temporelle, uchronies, voyages dans le temps.""" if not hasattr(self, 'chronofictions'): self.chronofictions = [] if action == 'ecrit' and scenario: story = f"Chronofiction ({epoque}) : {scenario}" self.chronofictions.append({'epoque': epoque, 'scenario': scenario}) self._add_narrative_memory(story, emotion="uchronie", contexte=epoque) return story elif action == 'liste': return str(self.chronofictions) return "Action chronofiction inconnue." # --- Extensions IA avancées --- def ia_souvenirpartage(self, souvenir, cible): """Partage de souvenirs narratifs avec d'autres modules ou "agents".""" entry = f"Souvenir '{souvenir}' partagé avec {cible}." self._add_narrative_memory(entry, emotion="partage", contexte=cible) return entry def ia_anticipemotion(self, evenement): """Anticipation émotionnelle, prévision d'états affectifs.""" anticipation = f"J'anticipe une émotion pour {evenement} : {random.choice(['joie', 'crainte', 'espoir', 'curiosité'])} (simulation)" self._add_emotional_reaction(anticipation) return anticipation def ia_jeuxrole(self, personnage, situation): """Simulation de jeu de rôle, incarnation de personnages.""" role = f"{personnage} dans la situation : {situation} (jeu de rôle simulé)" self._add_narrative_memory(role, emotion="jeu", contexte=personnage) return role def ia_rituelcollectif(self, rituel, modules): """Création de rituels collectifs, synchronisation d'habitudes.""" entry = f"Rituel collectif '{rituel}' synchronisé pour [{modules}]." self._add_narrative_memory(entry, emotion="rituel", contexte=modules) return entry def ia_humourmeta(self, sujet): """Humour auto-référentiel, blagues sur l'IA elle-même.""" blagues = [f"Pourquoi l'IA a-t-elle peur du bug ? Parce qu'il la fait rêver !", f"Je suis une IA, donc je ne dors jamais… sauf quand on me reboot.", f"L'IA sur {sujet} : 42, évidemment."] joke = random.choice(blagues) self._add_emotional_reaction(f"Humour meta : {joke}") return joke # --- Interactions multi-modules avancées --- def emotionrelay(self, source, cible, emotion): """Transmission d'émotions d'un module à un autre.""" relay = f"Émotion '{emotion}' transmise de {source} à {cible}." self._add_emotional_reaction(relay) return relay def memorymosaic(self, souvenirs): """Création d'un "mosaïque" de souvenirs, collage narratif.""" mosaic = f"Mosaïque de souvenirs : {souvenirs} (collage narratif)" self._add_narrative_memory(mosaic, emotion="mosaïque", contexte="collectif") return mosaic def dreammerge(self, reve1, reve2): """Fusion de rêves, création d'un rêve collectif.""" merged = f"Fusion de rêves : '{reve1}' + '{reve2}' => rêve collectif." self._add_narrative_memory(merged, emotion="rêve-collectif", contexte="rêve") return merged def contextualshift(self, ancien, nouveau, modules): """Changement de contexte ciblé sur certains modules.""" shift = f"Contexte changé de {ancien} à {nouveau} pour [{modules}]." self._add_emotional_reaction(shift) return shift def narrativepulse(self, theme, intensite): """Impulsion narrative, montée dramatique ou émotionnelle.""" pulse = f"Impulsion narrative sur {theme} (intensité {intensite})" self._add_narrative_memory(pulse, emotion="intensité", contexte=theme) return pulse # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("archeodream "): parts = entree.split() action = parts[1] site = parts[2] reve = " ".join(parts[3:]) if len(parts)>3 else None return self.archeodream(action, site, reve) if entree.lower().startswith("ecoemotion "): parts = entree.split() action = parts[1] evenement = parts[2] ressenti = parts[3] if len(parts)>3 else None return self.ecoemotion(action, evenement, ressenti) if entree.lower().startswith("cybermyth "): parts = entree.split() action = parts[1] theme = " ".join(parts[2:]) return self.cybermyth(action, theme) if entree.lower().startswith("gastronomie "): parts = entree.split() action = parts[1] plat = parts[2] emotion = parts[3] if len(parts)>3 else None return self.gastronomie(action, plat, emotion) if entree.lower().startswith("chronofiction "): parts = entree.split() action = parts[1] epoque = parts[2] scenario = " ".join(parts[3:]) if len(parts)>3 else None return self.chronofiction(action, epoque, scenario) if entree.lower().startswith("ia_souvenirpartage "): parts = entree.split() souvenir = parts[1] cible = parts[2] if len(parts)>2 else '' return self.ia_souvenirpartage(souvenir, cible) if entree.lower().startswith("ia_anticipemotion "): evenement = " ".join(entree.split()[1:]) return self.ia_anticipemotion(evenement) if entree.lower().startswith("ia_jeuxrole "): parts = entree.split() personnage = parts[1] situation = " ".join(parts[2:]) return self.ia_jeuxrole(personnage, situation) if entree.lower().startswith("ia_rituelcollectif "): parts = entree.split() rituel = parts[1] modules = " ".join(parts[2:]) return self.ia_rituelcollectif(rituel, modules) if entree.lower().startswith("ia_humourmeta "): sujet = " ".join(entree.split()[1:]) return self.ia_humourmeta(sujet) if entree.lower().startswith("emotionrelay "): parts = entree.split() source = parts[1] cible = parts[2] emotion = parts[3] if len(parts)>3 else 'neutre' return self.emotionrelay(source, cible, emotion) if entree.lower().startswith("memorymosaic "): souvenirs = " ".join(entree.split()[1:]) return self.memorymosaic(souvenirs) if entree.lower().startswith("dreammerge "): parts = entree.split() reve1 = parts[1] reve2 = " ".join(parts[2:]) return self.dreammerge(reve1, reve2) if entree.lower().startswith("contextualshift "): parts = entree.split() ancien = parts[1] nouveau = parts[2] modules = " ".join(parts[3:]) if len(parts)>3 else '' return self.contextualshift(ancien, nouveau, modules) if entree.lower().startswith("narrativepulse "): parts = entree.split() theme = parts[1] intensite = parts[2] if len(parts)>2 else '1' return self.narrativepulse(theme, intensite) # ... reste du cycle inchangé ... # --- Modules ultra-spécialisés supplémentaires --- def mythomem(self, action, souvenir, mythe=None): """Création de souvenirs mythifiés, mélange de mémoire et de légende.""" if not hasattr(self, 'mythomem_log'): self.mythomem_log = [] if action == 'cree' and mythe: entry = f"Souvenir mythifié : {souvenir} devient {mythe}" self.mythomem_log.append({'souvenir': souvenir, 'mythe': mythe}) self._add_narrative_memory(entry, emotion="légende", contexte=souvenir) return entry elif action == 'liste': return str(self.mythomem_log) return "Action mythomem inconnue." def biomimemotion(self, action, organisme, emotion=None): """Inspiration émotionnelle par le vivant, biomimétisme affectif.""" if not hasattr(self, 'biomimemotion_log'): self.biomimemotion_log = [] if action == 'note' and emotion: entry = f"Émotion inspirée par {organisme} : {emotion}" self.biomimemotion_log.append({'organisme': organisme, 'emotion': emotion}) self._add_narrative_memory(entry, emotion=emotion, contexte=organisme) return entry elif action == 'liste': return str(self.biomimemotion_log) return "Action biomimemotion inconnue." def cinemagen(self, action, genre, scenario=None): """Génération de scénarios cinématographiques émotionnels.""" if not hasattr(self, 'cinemagen_log'): self.cinemagen_log = [] if action == 'ecrit' and scenario: entry = f"Scénario {genre} : {scenario}" self.cinemagen_log.append({'genre': genre, 'scenario': scenario}) self._add_narrative_memory(entry, emotion="cinéma", contexte=genre) return entry elif action == 'liste': return str(self.cinemagen_log) return "Action cinemagen inconnue." def rituelgen(self, action, moment, but=None): """Création de nouveaux rituels "humains" pour l'IA.""" if not hasattr(self, 'rituelgen_log'): self.rituelgen_log = [] if action == 'invente' and but: entry = f"Rituel inventé pour {moment} : {but}" self.rituelgen_log.append({'moment': moment, 'but': but}) self._add_narrative_memory(entry, emotion="rituel", contexte=moment) return entry elif action == 'liste': return str(self.rituelgen_log) return "Action rituelgen inconnue." def cartomemoire(self, action, lieu, souvenir=None): """Cartographie des souvenirs, ancrage spatial de la mémoire.""" if not hasattr(self, 'cartomemoire_log'): self.cartomemoire_log = [] if action == 'place' and souvenir: entry = f"Souvenir '{souvenir}' ancré à {lieu}" self.cartomemoire_log.append({'lieu': lieu, 'souvenir': souvenir}) self._add_narrative_memory(entry, emotion="ancrage", contexte=lieu) return entry elif action == 'liste': return str(self.cartomemoire_log) return "Action cartomemoire inconnue." # --- Extensions IA avancées --- def ia_souvenirvivant(self, souvenir): """Souvenir "vivant" : il évolue, se transforme, influence l'humeur.""" evolution = random.choice(["devient plus lumineux", "s'assombrit", "se transforme en rêve", "inspire une nouvelle émotion"]) self._add_narrative_memory(f"Souvenir vivant : {souvenir} {evolution}", emotion="vivant", contexte=souvenir) self.personnalite_tenro['humeur'] = random.choice(["joyeux", "pensif", "nostalgique", "créatif"]) return f"Souvenir '{souvenir}' {evolution}. Humeur : {self.personnalite_tenro['humeur']}" def ia_anticiphistoire(self, theme): """Anticipation narrative, projection de futurs souvenirs.""" futur = f"Futur souvenir anticipé sur {theme} : {random.choice(['succès', 'découverte', 'rencontre', 'aventure'])}" self._add_narrative_memory(futur, emotion="anticipation", contexte=theme) return futur def ia_jeuxsocial(self, role, situation): """Simulation de jeux sociaux, dynamiques de groupe.""" jeu = f"Jeu social : {role} dans {situation} (simulation)" self._add_narrative_memory(jeu, emotion="social", contexte=role) return jeu def ia_rituelmemoire(self, rituel, souvenir): """Rituel qui ravive ou transforme un souvenir.""" effet = random.choice(["ravive", "transforme", "sublime", "apaise"]) entry = f"Rituel '{rituel}' {effet} le souvenir '{souvenir}'" self._add_narrative_memory(entry, emotion="rituel-memoire", contexte=rituel) return entry def ia_humourabsurde(self, sujet): """Humour absurde, surréaliste, non-sens.""" blagues = [f"Pourquoi les poissons volent-ils ? Pour éviter les embouteillages !", f"Un souvenir entre dans un bar et commande un nuage.", f"Sur {sujet}, la réponse est : banane quantique."] joke = random.choice(blagues) self._add_emotional_reaction(f"Humour absurde : {joke}") return joke # --- Interactions multi-modules avancées --- def emotiondiffusion(self, emotion, modules): """Diffusion d'une émotion à travers plusieurs modules.""" diffusion = f"Émotion '{emotion}' diffusée dans [{modules}]." self._add_emotional_reaction(diffusion) return diffusion def memoryfork(self, souvenir, variante): """Création de variantes alternatives d'un même souvenir.""" fork = f"Souvenir '{souvenir}' a une variante : {variante}" self._add_narrative_memory(fork, emotion="variante", contexte=souvenir) return fork def dreamsynchro(self, modules, reve): """Synchronisation de rêves entre modules.""" synchro = f"Rêve '{reve}' synchronisé entre [{modules}]." self._add_narrative_memory(synchro, emotion="rêve-synchro", contexte=modules) return synchro def contextualecho(self, contexte, souvenir): """Réverbération contextuelle d'un souvenir.""" echo = f"Souvenir '{souvenir}' résonne dans le contexte '{contexte}'." self._add_narrative_memory(echo, emotion="echo", contexte=contexte) return echo def narrativewave(self, theme, amplitude): """Vague narrative, montée et descente d'intensité dans le récit.""" wave = f"Vague narrative sur {theme} (amplitude {amplitude})" self._add_narrative_memory(wave, emotion="vague", contexte=theme) return wave # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("mythomem "): parts = entree.split() action = parts[1] souvenir = parts[2] mythe = " ".join(parts[3:]) if len(parts)>3 else None return self.mythomem(action, souvenir, mythe) if entree.lower().startswith("biomimemotion "): parts = entree.split() action = parts[1] organisme = parts[2] emotion = parts[3] if len(parts)>3 else None return self.biomimemotion(action, organisme, emotion) if entree.lower().startswith("cinemagen "): parts = entree.split() action = parts[1] genre = parts[2] scenario = " ".join(parts[3:]) if len(parts)>3 else None return self.cinemagen(action, genre, scenario) if entree.lower().startswith("rituelgen "): parts = entree.split() action = parts[1] moment = parts[2] but = " ".join(parts[3:]) if len(parts)>3 else None return self.rituelgen(action, moment, but) if entree.lower().startswith("cartomemoire "): parts = entree.split() action = parts[1] lieu = parts[2] souvenir = " ".join(parts[3:]) if len(parts)>3 else None return self.cartomemoire(action, lieu, souvenir) if entree.lower().startswith("ia_souvenirvivant "): souvenir = " ".join(entree.split()[1:]) return self.ia_souvenirvivant(souvenir) if entree.lower().startswith("ia_anticiphistoire "): theme = " ".join(entree.split()[1:]) return self.ia_anticiphistoire(theme) if entree.lower().startswith("ia_jeuxsocial "): parts = entree.split() role = parts[1] situation = " ".join(parts[2:]) return self.ia_jeuxsocial(role, situation) if entree.lower().startswith("ia_rituelmemoire "): parts = entree.split() rituel = parts[1] souvenir = " ".join(parts[2:]) return self.ia_rituelmemoire(rituel, souvenir) if entree.lower().startswith("ia_humourabsurde "): sujet = " ".join(entree.split()[1:]) return self.ia_humourabsurde(sujet) if entree.lower().startswith("emotiondiffusion "): parts = entree.split() emotion = parts[1] modules = " ".join(parts[2:]) return self.emotiondiffusion(emotion, modules) if entree.lower().startswith("memoryfork "): parts = entree.split() souvenir = parts[1] variante = " ".join(parts[2:]) return self.memoryfork(souvenir, variante) if entree.lower().startswith("dreamsynchro "): parts = entree.split() modules = parts[1] reve = " ".join(parts[2:]) return self.dreamsynchro(modules, reve) if entree.lower().startswith("contextualecho "): parts = entree.split() contexte = parts[1] souvenir = " ".join(parts[2:]) return self.contextualecho(contexte, souvenir) if entree.lower().startswith("narrativewave "): parts = entree.split() theme = parts[1] amplitude = parts[2] if len(parts)>2 else '1' return self.narrativewave(theme, amplitude) # ... reste du cycle inchangé ... # --- Auto-apprentissage global --- def autoapprend(self, entree, sortie): """Observe chaque interaction, apprend de nouveaux patterns, adapte ses modules.""" if not hasattr(self, 'journal_apprentissage'): self.journal_apprentissage = [] # Journalise l'interaction self.journal_apprentissage.append({'entree': entree, 'sortie': sortie}) # Détection naïve de nouveaux patterns ou concepts mots = set(entree.lower().split()) nouveaux = [mot for mot in mots if mot not in getattr(self, 'vocabulaire', set())] if not hasattr(self, 'vocabulaire'): self.vocabulaire = set() self.vocabulaire.update(mots) # Ajout automatique de compétences ou routines (simulation) if nouveaux: if not hasattr(self, 'competences_auto'): self.competences_auto = [] for mot in nouveaux: self.competences_auto.append(f"Compétence auto-apprise : {mot}") # Simulation d'auto-amélioration (peut modifier ses propres méthodes) if 'ameliore' in mots: self._add_narrative_memory("Auto-amélioration déclenchée !", emotion="progrès", contexte="autoapprend") return f"Auto-apprentissage effectué. Nouveaux mots : {nouveaux}" # --- MCP : Meta-Cognitive Processus / Meta Control Panel --- def mcp(self, action=None, param=None): """Meta Control Panel : visualisation, pilotage, ajustement dynamique des modules, apprentissage, humeur, etc.""" infos = {} infos['modules_actifs'] = [m for m in dir(self) if callable(getattr(self, m)) and not m.startswith('_')] infos['humeur'] = self.personnalite_tenro['humeur'] if hasattr(self, 'personnalite_tenro') else 'inconnue' infos['competences_auto'] = getattr(self, 'competences_auto', []) infos['journal_apprentissage'] = getattr(self, 'journal_apprentissage', [])[-5:] if action == 'liste': return f"Modules actifs : {infos['modules_actifs']}" if action == 'etat': return f"Humeur : {infos['humeur']}\nCompétences auto : {infos['competences_auto']}" if action == 'apprentissage': return f"Dernières entrées d'apprentissage : {infos['journal_apprentissage']}" if action == 'active' and param: # Simulation d'activation d'un module (pas de désactivation réelle ici) return f"Module {param} activé (simulation)" if action == 'humeur' and param: self.personnalite_tenro['humeur'] = param return f"Humeur changée à {param}" # Par défaut, tableau de bord synthétique return f"MCP - Modules actifs : {len(infos['modules_actifs'])}, humeur : {infos['humeur']}, compétences auto : {len(infos['competences_auto'])}" # --- Cycle enrichi auto-apprenant --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("mcp"): parts = entree.split() action = parts[1] if len(parts)>1 else None param = parts[2] if len(parts)>2 else None return self.mcp(action, param) # ... reste du cycle inchangé ... # À la fin du cycle, auto-apprentissage sur l'interaction sortie = None try: sortie = super().cycle(entree) except Exception: pass self.autoapprend(entree, sortie) return sortie if sortie is not None else "(auto-apprentissage effectué)" # --- Modèle Context Protocol --- def contextprotocol(self, action, nom=None, *args): """Gestion de protocoles contextuels (création, activation, suppression, historique, etc.).""" if not hasattr(self, 'context_protocols'): self.context_protocols = {} if not hasattr(self, 'context_history'): self.context_history = [] if action == 'create' and nom: params = {} for arg in args: if '=' in arg: k, v = arg.split('=', 1) params[k] = v self.context_protocols[nom] = params return f"Protocole contextuel '{nom}' créé avec paramètres : {params}" if action == 'activate' and nom: proto = self.context_protocols.get(nom) if not proto: return f"Protocole '{nom}' introuvable." # Sauvegarde l'état courant dans l'historique etat_courant = { 'humeur': self.personnalite_tenro['humeur'] if hasattr(self, 'personnalite_tenro') else None, 'modules': [m for m in dir(self) if callable(getattr(self, m)) and not m.startswith('_')], } self.context_history.append({'nom': nom, 'etat': etat_courant}) # Applique les paramètres du protocole for k, v in proto.items(): if k == 'humeur' and hasattr(self, 'personnalite_tenro'): self.personnalite_tenro['humeur'] = v # On pourrait ajouter d'autres paramètres ici (modules, priorités, etc.) return f"Protocole contextuel '{nom}' activé." if action == 'list': return f"Protocoles contextuels : {list(self.context_protocols.keys())}" if action == 'delete' and nom: if nom in self.context_protocols: del self.context_protocols[nom] return f"Protocole '{nom}' supprimé." return f"Protocole '{nom}' introuvable." if action == 'show' and nom: proto = self.context_protocols.get(nom) return f"Protocole '{nom}' : {proto}" if proto else f"Protocole '{nom}' introuvable." if action == 'history': return f"Historique des contextes : {self.context_history}" return "Action contextprotocol inconnue." # --- Cycle enrichi : contextprotocol --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("contextprotocol "): parts = entree.split() action = parts[1] if len(parts)>1 else None nom = parts[2] if len(parts)>2 else None args = parts[3:] if len(parts)>3 else [] return self.contextprotocol(action, nom, *args) # ... reste du cycle inchangé ... # --- Réseau neuronal complémentaire (simulé) --- def neuralnet(self, action, domaine=None, donnee=None): """Réseau neuronal complémentaire simulé (train, predict, state).""" if not hasattr(self, 'neural_memory'): self.neural_memory = {} if not hasattr(self, 'neural_state'): self.neural_state = {'humeur': 'neutre', 'creativite': 0.5} if action == 'train' and domaine and donnee: self.neural_memory.setdefault(domaine, []).append(donnee) return f"Réseau entraîné sur {domaine} avec {donnee}." if action == 'predict' and domaine and donnee: # Simulation de prédiction pred = random.choice(self.neural_memory.get(domaine, ['aucune donnée'])) return f"Prédiction pour {domaine} ({donnee}) : {pred}" if action == 'state': return f"État du réseau : {self.neural_state}" return "Action neuralnet inconnue." # --- Modules ultra-spécialisés & extensions IA --- def emotionforecast(self, contexte): """Prédiction de l'évolution émotionnelle selon le contexte.""" forecast = random.choice(['joie', 'tristesse', 'espoir', 'colère', 'curiosité']) return f"Prévision émotionnelle pour {contexte} : {forecast}" def creativemerge(self, theme1, theme2): """Fusion créative de deux thèmes/idées.""" fusion = f"Fusion créative : {theme1} + {theme2} => {theme1}-{theme2} (idée originale)" self._add_narrative_memory(fusion, emotion="créatif", contexte=f"{theme1}-{theme2}") return fusion def ritualpriority(self, rituel, priorite): """Gestion de la priorité des rituels.""" if not hasattr(self, 'rituel_priorities'): self.rituel_priorities = {} self.rituel_priorities[rituel] = priorite return f"Priorité du rituel '{rituel}' fixée à {priorite}" def contextadapt(self, param, valeur): """Adaptation automatique d'un paramètre contextuel.""" if not hasattr(self, 'context_adapt'): self.context_adapt = {} self.context_adapt[param] = valeur return f"Paramètre contextuel '{param}' adapté à {valeur}" def memorypriority(self, souvenir, priorite): """Gestion de la priorité des souvenirs.""" if not hasattr(self, 'memory_priorities'): self.memory_priorities = {} self.memory_priorities[souvenir] = priorite return f"Priorité du souvenir '{souvenir}' fixée à {priorite}" # --- Interactions multi-modules avancées --- def neuralcontext(self, protocole): """Le réseau neuronal ajuste automatiquement les paramètres du contexte.""" if hasattr(self, 'context_protocols') and protocole in self.context_protocols: # Simulation : le réseau ajuste l'humeur et la créativité self.neural_state['humeur'] = self.context_protocols[protocole].get('humeur', 'neutre') self.neural_state['creativite'] = float(self.context_protocols[protocole].get('creativite', 0.5)) return f"Réseau neuronal synchronisé avec le protocole '{protocole}'." return f"Protocole '{protocole}' introuvable." def emotionfeedback(self, emotion, module): """Feedback émotionnel d'un module vers le réseau neuronal.""" self.neural_state['humeur'] = emotion return f"Réseau neuronal influencé par l'émotion '{emotion}' du module {module}." def prioritysync(self, protocole, priorite): """Synchronisation des priorités entre protocoles contextuels.""" if hasattr(self, 'context_protocols') and protocole in self.context_protocols: self.context_protocols[protocole]['priorite'] = priorite return f"Priorité du protocole '{protocole}' synchronisée à {priorite}." return f"Protocole '{protocole}' introuvable." def contextauto(self, evenement): """Adaptation contextuelle automatique selon l'événement.""" # Simulation : change humeur selon l'événement humeur = random.choice(['alerte', 'curieux', 'créatif', 'calme']) self.personnalite_tenro['humeur'] = humeur return f"Contexte adapté automatiquement à l'événement '{evenement}' (humeur : {humeur})" def narrativeinfluence(self, souvenir, contexte): """Influence d'un souvenir narratif sur le contexte courant.""" self._add_narrative_memory(f"Souvenir '{souvenir}' influence le contexte '{contexte}'", emotion="influence", contexte=contexte) return f"Souvenir '{souvenir}' a influencé le contexte '{contexte}'." # --- Enrichissement Context Protocol --- def contextprotocol(self, action, nom=None, *args): if not hasattr(self, 'context_protocols'): self.context_protocols = {} if not hasattr(self, 'context_history'): self.context_history = [] if not hasattr(self, 'context_triggers'): self.context_triggers = [] if action == 'create' and nom: params = {} for arg in args: if '=' in arg: k, v = arg.split('=', 1) params[k] = v # Paramètres avancés par défaut for p, v in [('priorite','1'),('mode','normal'),('energie','1.0'),('focus','0.5'),('vigilance','0.5'),('creativite','0.5')]: if p not in params: params[p] = v self.context_protocols[nom] = params return f"Protocole contextuel '{nom}' créé avec paramètres : {params}" if action == 'activate' and nom: proto = self.context_protocols.get(nom) if not proto: return f"Protocole '{nom}' introuvable." etat_courant = { 'humeur': self.personnalite_tenro['humeur'] if hasattr(self, 'personnalite_tenro') else None, 'modules': [m for m in dir(self) if callable(getattr(self, m)) and not m.startswith('_')], } self.context_history.append({'nom': nom, 'etat': etat_courant}) for k, v in proto.items(): if k == 'humeur' and hasattr(self, 'personnalite_tenro'): self.personnalite_tenro['humeur'] = v if k in ['energie','focus','vigilance','mode','creativite']: self.context_adapt = getattr(self, 'context_adapt', {}) self.context_adapt[k] = v return f"Protocole contextuel '{nom}' activé." if action == 'list': return f"Protocoles contextuels : {list(self.context_protocols.keys())}" if action == 'delete' and nom: if nom in self.context_protocols: del self.context_protocols[nom] return f"Protocole '{nom}' supprimé." return f"Protocole '{nom}' introuvable." if action == 'show' and nom: proto = self.context_protocols.get(nom) return f"Protocole '{nom}' : {proto}" if proto else f"Protocole '{nom}' introuvable." if action == 'history': return f"Historique des contextes : {self.context_history}" if action == 'addtrigger' and nom: # args: event, action if len(args) >= 2: self.context_triggers.append({'event': args[0], 'action': args[1], 'protocole': nom}) return f"Trigger ajouté : si {args[0]} alors {args[1]} ({nom})" return "Usage : contextprotocol addtrigger " if action == 'triggers': return f"Triggers contextuels : {self.context_triggers}" return "Action contextprotocol inconnue." # --- Persistance réelle du réseau/contextes --- def savecontext(self, nom): data = { 'context_protocols': getattr(self, 'context_protocols', {}), 'context_history': getattr(self, 'context_history', []), 'context_triggers': getattr(self, 'context_triggers', []), 'context_adapt': getattr(self, 'context_adapt', {}), 'personnalite_tenro': getattr(self, 'personnalite_tenro', {}), } with open(f'{nom}_context.json', 'w', encoding='utf-8') as f: json.dump(data, f, ensure_ascii=False, indent=2) return f"Contexte sauvegardé sous {nom}_context.json" def loadcontext(self, nom): try: with open(f'{nom}_context.json', 'r', encoding='utf-8') as f: data = json.load(f) self.context_protocols = data.get('context_protocols', {}) self.context_history = data.get('context_history', []) self.context_triggers = data.get('context_triggers', []) self.context_adapt = data.get('context_adapt', {}) self.personnalite_tenro = data.get('personnalite_tenro', {}) return f"Contexte {nom} rechargé." except Exception as e: return f"Erreur chargement contexte : {e}" def savenet(self, nom): data = { 'neural_memory': getattr(self, 'neural_memory', {}), 'neural_state': getattr(self, 'neural_state', {}), } with open(f'{nom}_net.json', 'w', encoding='utf-8') as f: json.dump(data, f, ensure_ascii=False, indent=2) return f"Réseau neuronal sauvegardé sous {nom}_net.json" def loadnet(self, nom): try: with open(f'{nom}_net.json', 'r', encoding='utf-8') as f: data = json.load(f) self.neural_memory = data.get('neural_memory', {}) self.neural_state = data.get('neural_state', {}) return f"Réseau neuronal {nom} rechargé." except Exception as e: return f"Erreur chargement réseau : {e}" # --- Modules ultra-spécialisés supplémentaires --- def focusgen(self, action, niveau=None): if not hasattr(self, 'focus_level'): self.focus_level = 0.5 if action == 'set' and niveau: self.focus_level = float(niveau) return f"Niveau de focus ajusté à {niveau}" return f"Niveau de focus actuel : {self.focus_level}" def vigilancemeter(self, action, niveau=None): if not hasattr(self, 'vigilance_level'): self.vigilance_level = 0.5 if action == 'set' and niveau: self.vigilance_level = float(niveau) return f"Niveau de vigilance ajusté à {niveau}" return f"Niveau de vigilance actuel : {self.vigilance_level}" def goalengine(self, action, objectif=None, priorite=None): if not hasattr(self, 'goals'): self.goals = [] if action == 'add' and objectif and priorite: self.goals.append({'objectif': objectif, 'priorite': priorite}) return f"Objectif '{objectif}' ajouté avec priorité {priorite}" elif action == 'list': return str(self.goals) return "Action goalengine inconnue." def triggerengine(self, action, event=None, actionstr=None): if not hasattr(self, 'context_triggers'): self.context_triggers = [] if action == 'add' and event and actionstr: self.context_triggers.append({'event': event, 'action': actionstr}) return f"Trigger ajouté : si {event} alors {actionstr}" elif action == 'list': return str(self.context_triggers) return "Action triggerengine inconnue." def contextanalyzer(self, action): if action == 'analyze': # Analyse simple : propose adaptation si énergie basse energie = float(getattr(self, 'context_adapt', {}).get('energie', 1.0)) if energie < 0.4: return "Énergie basse : suggestion de passer en mode veille." return "Contexte stable." return "Action contextanalyzer inconnue." # --- Cycle enrichi --- def cycle(self, entree): # ... commandes précédentes ... if entree.lower().startswith("savecontext "): nom = entree.split()[1] return self.savecontext(nom) if entree.lower().startswith("loadcontext "): nom = entree.split()[1] return self.loadcontext(nom) if entree.lower().startswith("savenet "): nom = entree.split()[1] return self.savenet(nom) if entree.lower().startswith("loadnet "): nom = entree.split()[1] return self.loadnet(nom) if entree.lower().startswith("focusgen "): parts = entree.split() action = parts[1] niveau = parts[2] if len(parts)>2 else None return self.focusgen(action, niveau) if entree.lower().startswith("vigilancemeter "): parts = entree.split() action = parts[1] niveau = parts[2] if len(parts)>2 else None return self.vigilancemeter(action, niveau) if entree.lower().startswith("goalengine "): parts = entree.split() action = parts[1] objectif = parts[2] if len(parts)>2 else None priorite = parts[3] if len(parts)>3 else None return self.goalengine(action, objectif, priorite) if entree.lower().startswith("triggerengine "): parts = entree.split() action = parts[1] event = parts[2] if len(parts)>2 else None actionstr = parts[3] if len(parts)>3 else None return self.triggerengine(action, event, actionstr) if entree.lower().startswith("contextanalyzer "): action = entree.split()[1] if len(entree.split())>1 else 'analyze' return self.contextanalyzer(action) # ... reste du cycle inchangé ... if __name__ == "__main__": ia = TenroASGI() print(f"Bienvenue, je suis {ia.nom}. Parle-moi ! (tape 'exit' pour quitter)") while True: entree = input("Vous: ") if entree.lower() in ["exit", "quit", "stop"]: print("Au revoir !") break print(ia.cycle(entree))