bonjour, je cherche a convertir un fichier python en exe mais je ny arrive pas, merci de bien vouloir m'aider ,
Voici le code :
# ============================================================
# BIOSCRIPT SYMBOLIQUE · Bt p (VERSION AMÉLIORÉE AVEC MENU PRÉCIS)
# ============================================================
import math
import json
import os
from datetime import datetime
# ============================================================
# CONFIGURATION
# ============================================================
MODULO_STANDARD = 26
MEMOIRE_FICHIER = "memoire_symbolique.json"
# ============================================================
# BASES SYMBOLIQUES
# ============================================================
BASE_NUMERIQUE = {
0: "INERTE",
1: "INTRINSEQUE",
2: "ECHANGE",
3: "BEAU",
4: "STRUCTURE",
5: "BONHEUR",
6: "RUPTURE",
7: "ILLUSION",
8: "EQUILIBRE",
9: "FIN / TRANSITION"
}
BASE_ALPHABETIQUE = {
1: ("A", "INTRINSEQUE"),
2: ("B", "ECHANGE"),
3: ("C", "SUBLIME"),
4: ("D", "STRUCTURE"),
5: ("E", "COEUR"),
6: ("F", "FORCE"),
7: ("G", "ILLUSION"),
8: ("H", "EQUILIBRE"),
9: ("I", "MORT"),
10: ("J", "IMPACT"),
11: ("K", "CANALISEUR"),
12: ("L", "ALPHA"),
13: ("M", "JOIE"),
14: ("N", "HAINE"),
15: ("O", "PASSION"),
16: ("P", "PARADIS"),
17: ("Q", "SEXE"),
18: ("R", "RESILIENCE"),
19: ("S", "ONDE"),
20: ("T", "SOLIDE"),
21: ("U", "RETENTION"),
22: ("V", "VECTEUR"),
23: ("W", "SHEYTAN"),
24: ("X", "LION"),
25: ("Y", "VERITE"),
26: ("Z", "NUL / 0")
}
OTAN = {
1: "ALPHA", 2: "BRAVO", 3: "CHARLIE", 4: "DELTA",
5: "ECHO", 6: "FOXTROT", 7: "GOLF", 8: "HOTEL",
9: "INDIA", 10: "JULIETT", 11: "KILO", 12: "LIMA",
13: "MIKE", 14: "NOVEMBER", 15: "OSCAR", 16: "PAPA",
17: "QUEBEC", 18: "ROMEO", 19: "SIERRA", 20: "TANGO",
21: "UNIFORM", 22: "VICTOR", 23: "WHISKEY",
24: "XRAY", 25: "YANKEE", 26: "ZULU"
}
# ============================================================
# MÉMOIRE PERSISTANTE
# ============================================================
def charger_memoire():
if os.path.exists(MEMOIRE_FICHIER):
try:
with open(MEMOIRE_FICHIER, "r") as f:
return json.load(f)
except:
return []
return []
def sauvegarder_memoire():
with open(MEMOIRE_FICHIER, "w") as f:
json.dump(memoire_dynamique, f, indent=4)
memoire_dynamique = charger_memoire()
def memoire_log(texte):
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
memoire_dynamique.append(f"[{timestamp}] {texte}")
sauvegarder_memoire()
# ============================================================
# OUTILS
# ============================================================
def appliquer_modulo(valeur, modulo):
if modulo == 0:
return valeur
r = valeur % modulo
return r if r != 0 else modulo
def valeur_lettres(mot):
total = 0
for c in mot:
if c.isalpha():
brut = ord(c.upper()) - 64
val_mod = appliquer_modulo(brut, 26)
total += val_mod
return total
def demander_modulo(defaut=MODULO_STANDARD):
m = input(f"Choisir un modulo (Entrée={defaut}) : ").strip()
return int(m) if m.isdigit() and int(m) > 0 else defaut
def convertir_valeur(token):
token = token.strip()
if token.isnumeric():
return int(token)
return valeur_lettres(token)
def lettre_et_sens(valeur_mod):
val_mod_26 = appliquer_modulo(valeur_mod, 26)
lettre, sens = BASE_ALPHABETIQUE.get(val_mod_26, ("?", "?"))
return lettre, sens
def afficher_resultat_tableau(valeur, modulo):
valeur_mod = appliquer_modulo(valeur, modulo)
rn = valeur_mod % 10
lettre, sens = lettre_et_sens(valeur_mod)
print(f"{valeur} Modulo {modulo} {valeur_mod} {lettre} {sens} Numérologie {rn} {BASE_NUMERIQUE.get(rn, 'INCONNU')}")
memoire_log(f"{valeur} Modulo {modulo} {valeur_mod} {lettre} {sens}")
# ============================================================
# TABLEAUX
# ============================================================
def afficher_tableaux():
print("\n========================= TABLEAU SYMBOLIQUE =========================\n")
print("---------------------- BASE NUMÉRIQUE ----------------------")
for k, v in BASE_NUMERIQUE.items():
print(f"{k} {v}")
print("\n---------------------- BASE ALPHABÉTIQUE ----------------------")
for k, (lettre, sens) in BASE_ALPHABETIQUE.items():
print(f"{k:2} {lettre} {sens}")
print("\n---------------------- BASE OTAN ----------------------")
modulo_otan = demander_modulo()
for k, mot in OTAN.items():
brut = valeur_lettres(mot)
val_mod = appliquer_modulo(brut, modulo_otan)
lettre, sens = lettre_et_sens(val_mod)
print(f"{k:2} : {mot} = {brut} Modulo {modulo_otan} {val_mod} {lettre} {sens}")
# ============================================================
# CALCULS
# ============================================================
def calcul_une_ligne():
modulo = demander_modulo()
ligne = input("Expression (+e +5 -12 ...) : ").strip()
tokens = ligne.replace("+", " +").replace("-", " -").split()
total = 0
for t in tokens:
if t.startswith("+"):
total += convertir_valeur(t[1:])
elif t.startswith("-"):
total -= convertir_valeur(t[1:])
afficher_resultat_tableau(total, modulo)
def langage_otan():
entree = input("Valeur / mot : ").strip()
valeur = convertir_valeur(entree)
modulo = demander_modulo()
total = 0
print("\n--- OTAN Lettre par lettre ---")
for c in entree:
if c.isalpha():
val = valeur_lettres(c)
mod_val = appliquer_modulo(val, modulo)
lettre, sens = lettre_et_sens(mod_val)
print(f"{c} {mod_val} {lettre} {sens}")
total += mod_val
afficher_resultat_tableau(total, modulo)
def oracle_narratif():
if not memoire_dynamique:
print("\nOracle : mémoire vide.")
return
print("\n================ ORACLE =================")
print(memoire_dynamique[-1])
print("========================================")
def afficher_memoire():
print("\n--- MÉMOIRE DYNAMIQUE ---\n")
for item in memoire_dynamique:
print(item)
input("\n[Entrée] pour revenir...")
# ============================================================
# MENU
# ============================================================
def menu():
afficher_tableaux()
while True:
try:
print("""
=========================== MENU SYMBOLIQUE ===========================
1) Transcription mot / nombre avec choix de modulo
[ ex : amour = 16 modulo 26 = PARADIS ]
2) Fusion / multiplication
[ ex : saisir le nombre de "mot/nombre" à multiplier, puis chaque "mot/nombre" pour les multiplier ]
3) Noyau / Carré
[ affiche le carrée, noyaux (son cliché principal) ]
4) Oracle narratif
5) Addition / soustraction / multiplication
[ ex : +m(13) +9(i) -k(11) = 32 modulo 26 = 6 ]
6) Comparaison entre 2 valeurs
[ saisir les valeurs comme demandé ]
7) Langage de l'OTAN
[ Transcrire un mot/nombre choix du modulo opérations comme les autres choix ]
8) Mémoire dynamique
0) Quitter (script actif)
======================================================================
""")
choix = input("Choix : ").strip()
if choix == "1":
modulo = demander_modulo()
v = convertir_valeur(input("Valeur / mot : "))
afficher_resultat_tableau(v, modulo)
elif choix == "2":
modulo = demander_modulo()
n = int(input("Nombre de valeurs : "))
r = 1
for _ in range(n):
r *= convertir_valeur(input("Valeur : "))
afficher_resultat_tableau(r, modulo)
elif choix == "3":
modulo = demander_modulo()
v = convertir_valeur(input("Valeur : "))
afficher_resultat_tableau(v ** 2, modulo)
elif choix == "4":
oracle_narratif()
elif choix == "5":
calcul_une_ligne()
elif choix == "6":
modulo = demander_modulo()
v1 = convertir_valeur(input("Valeur 1 : "))
v2 = convertir_valeur(input("Valeur 2 : "))
resultat = v1 - v2
print(f"\nSoustraction : {v1} - {v2} = {resultat}")
afficher_resultat_tableau(resultat, modulo)
elif choix == "7":
langage_otan()
elif choix == "8":
afficher_memoire()
elif choix == "0":
break
except Exception as e:
print("Erreur :", e)
# ============================================================
# LANCEMENT
# ============================================================
menu()
Merci d'avance
