feat: refactor & removed mt & missing numpy dep

constants.py

@@ -0,0 +1,12 @@
+NOMBRE_TIRAGE = 100
+NOMBRE_NUMEROS = 5
+MAX_NUMERO = 50
+NOMBRE_ETOILES = 2
+MAX_ETOILE = 12
+OPENMETEO_API_URL = "https://api.open-meteo.com/v1/forecast"
+OPENMETEO_HOURLY_PARAMS = [
+    "temperature_2m", "relative_humidity_2m", "wind_speed_10m",
+    "visibility", "precipitation", "cloud_cover", "pressure_msl",
+    "surface_pressure", "wind_direction_10m", "shortwave_radiation",
+    "direct_radiation", "diffuse_radiation", "dew_point_2m"
+]

main.py

@@ -1,3 +1,7 @@
+"""
+Ce script génère des tirages aléatoires pour l'EuroMillions en utilisant des sources d'entropie variées.
+"""
+
 import os
 import time
 import hashlib
@@ -11,183 +15,153 @@ import threading
 import datetime
 import multiprocessing
 from progress.bar import Bar
-from concurrent.futures import ProcessPoolExecutor
 import openmeteo_requests
 import requests_cache
+import numpy as _
 from retry_requests import retry
+from constants import *
 
-def fetch_weather_entropy():
+def _fetch_weather_api(params):
-    """Récupère des données météo comme source supplémentaire d'entropie"""
+    """Internal function to make Open-Meteo API requests"""
-    try:
+    cache_session = requests_cache.CachedSession('.cache', expire_after=60)
-        # Configuration du client API Open-Meteo avec cache et nouvelle tentative en cas d'erreur
+    retry_session = retry(cache_session, retries=2, backoff_factor=0.2)
-        cache_session = requests_cache.CachedSession('.cache', expire_after=60)  # Courte durée de cache
-        retry_session = retry(cache_session, retries=2, backoff_factor=0.2)  # Nouvelle tentative rapide
     openmeteo = openmeteo_requests.Client(session=retry_session)
+    return openmeteo.weather_api(OPENMETEO_API_URL, params=params)
 
-        # Demande de données météo avec un délai d'expiration
+def _get_weather_data():
-        url = "https://api.open-meteo.com/v1/forecast"
+    """Fonction interne qui récupère les données météo de l'API"""
     params = {
-            "latitude": 50.4,
+        "latitude": random.uniform(-70, 70),
-            "longitude": 1.83,
+        "longitude": random.uniform(-180, 180),
-            "hourly": ["temperature_2m", "relative_humidity_2m", "wind_speed_10m", 
+        "hourly": random.sample(OPENMETEO_HOURLY_PARAMS, random.randint(3, 6)),
-                      "visibility", "precipitation", "cloud_cover"],
         "timezone": "auto"
     }
 
-        responses = openmeteo.weather_api(url, params=params)
+    responses = _fetch_weather_api(params)
-        response = responses[0]
-
-        # Extraction de toutes les valeurs numériques des prévisions horaires
     entropy_values = []
-        hourly = response.Hourly()
-
-        # Traitement de chaque variable météorologique
     for i in range(len(params["hourly"])):
-            var_values = hourly.Variables(i).ValuesAsNumpy()
+        var_values = responses[0].Hourly().Variables(i).ValuesAsNumpy()
         entropy_values.extend(var_values.tolist())
 
-        # Création d'un hash de toutes les données météorologiques
     weather_str = "".join([str(v) for v in entropy_values])
-        weather_hash = hashlib.sha256(weather_str.encode()).hexdigest()
+    return hashlib.sha256(weather_str.encode()).hexdigest()
 
-        return weather_hash
+def get_weather_entropy():
+    """Récupère des données météo comme source supplémentaire d'entropie"""
+    try:
+        return _get_weather_data()
     except Exception as e:
-        # If anything fails, return a timestamp-based fallback
+        print(f"Erreur lors de la récupération des données météo: {e}")
         fallback = f"weather_fallback_{time.time()}_{random.getrandbits(64)}"
         return hashlib.sha256(fallback.encode()).hexdigest()
 
-def initialize_entropy_pool():
+def get_static_entropy_pool():
     """Crée un pool d'entropie de base avec des sources qui ne changent pas rapidement"""
-    weather_entropy = fetch_weather_entropy()
+    weather_entropy = get_weather_entropy()
-
     return [
-        str(os.urandom(32)),  # 32 octets d'aléa du système
+        str(os.urandom(32)),
-        str(secrets.token_bytes(32)),  # Autre source cryptographique
+        str(secrets.token_bytes(32)),
-        socket.gethostname(),  # Nom de l'hôte
+        socket.gethostname(),
         str(platform.system_alias(platform.system(), platform.release(), platform.version())),
-        str(uuid.getnode()),  # Adresse MAC
+        str(uuid.getnode()),
-        str(multiprocessing.cpu_count()),  # Nombre de CPU
+        str(multiprocessing.cpu_count()),
-        "".join([str(v) for v in psutil.disk_partitions()]),  # Configuration des disques
+        "".join([str(v) for v in psutil.disk_partitions()]),
-        str(hash(frozenset(os.environ.items()))),  # Variables d'environnement,
+        str(hash(frozenset(os.environ.items()))),
-        weather_entropy, # Données météorologiques
+        weather_entropy,
+    ]
+
+def get_dynamic_entropy_pool():
+    """Récupère des données dynamiques pour ajouter de l'entropie"""
+    return [
+        str(time.time()),
+        hashlib.sha256(str(time.perf_counter()).encode()).hexdigest(),
+        str(os.getpid()),
+        str(psutil.cpu_percent(interval=0.01)),
+        str(psutil.virtual_memory().percent),
+        str(psutil.disk_usage('/').percent),
+        str(random.getrandbits(256)),
+        str(datetime.datetime.now().microsecond),
+        str(threading.active_count()),
+        str(sum(psutil.cpu_times())),
+        str(psutil.net_io_counters().bytes_sent if hasattr(psutil, 'net_io_counters') else 0),
+        str(id({})),
     ]
 
 def generate_seed(base_pool=None):
     """Génère une graine aléatoire en combinant différentes sources d'entropie"""
-    # Utiliser le pool de base si fourni, sinon créer des sources complètes
+    entropy_sources = base_pool.copy() if base_pool else []
-    if base_pool:
+    entropy_sources.extend(get_dynamic_entropy_pool())
-        entropy_sources = base_pool.copy()
-    else:
-        entropy_sources = []
-
-    # Ajouter les sources dynamiques qui changent à chaque appel
-    dynamic_sources = [
-        str(time.time()),  # Timestamp actuel
-        hashlib.sha256(str(time.perf_counter()).encode()).hexdigest(),  # Timer haute précision hashé
-        str(os.getpid()),  # ID du processus
-        str(psutil.cpu_percent(interval=0.01)),  # Utilisation CPU (réduit à 0.01)
-        str(psutil.virtual_memory().percent),  # Utilisation mémoire
-        str(psutil.disk_usage('/').percent),  # Utilisation disque
-        str(random.getrandbits(256)),  # Bits aléatoires du générateur par défaut
-        str(datetime.datetime.now().microsecond),  # Microsecondes actuelles
-        str(threading.active_count()),  # Nombre de threads actifs
-        str(sum(psutil.cpu_times())),  # Temps CPU cumulés
-        str(psutil.net_io_counters().bytes_sent if hasattr(psutil, 'net_io_counters') else 0),  # Trafic réseau
-        str(id({})),  # Adresse mémoire d'un nouvel objet
-    ]
-
-    entropy_sources.extend(dynamic_sources)
-
     random.shuffle(entropy_sources)
 
-    # Concaténer et hacher plusieurs fois avec différents algorithmes
     entropy_str = "".join(entropy_sources)
     intermediate_hash = hashlib.sha512(entropy_str.encode()).digest()
     intermediate_hash = hashlib.blake2b(intermediate_hash).digest()
 
-    # Utiliser un hachage final pour obtenir un entier
     final_hash = hashlib.sha256(intermediate_hash).hexdigest()
-    seed = int(final_hash, 16)
+    return int(final_hash, 16)
-
-    return seed
 
 def faire_tirage(base_pool=None):
-    """Génère un tirage avec 5 numéros et 2 étoiles en utilisant une graine aléatoire"""
+    """Génère un tirage avec N numéros et M étoiles en utilisant une graine aléatoire"""
-    # Génération de nouveaux nombres avec une nouvelle graine
     seed = generate_seed(base_pool)
     random.seed(seed)
-    numeros = random.sample(range(1, 51), 5)
+    numeros = random.sample(range(1, MAX_NUMERO + 1), NOMBRE_NUMEROS)
-    etoiles = random.sample(range(1, 13), 2)
+    etoiles = random.sample(range(1, MAX_ETOILE + 1), NOMBRE_ETOILES)
     return {
         "graine": seed,
         "numeros": sorted(numeros),
         "etoiles": sorted(etoiles)
     }
 
-def worker_process(num_tirages, base_pool):
-    """Fonction exécutée par chaque processus travailleur"""
-    local_tirages = []
-    for _ in range(num_tirages):
-        local_tirages.append(faire_tirage(base_pool))
-    return local_tirages
-
 def generate_draws(num_tirages):
-    """Génère plusieurs tirages en parallèle"""
+    """Génère plusieurs tirages séquentiellement"""
-    # Initialiser le pool d'entropie de base
+    base_pool = get_static_entropy_pool()
-    base_pool = initialize_entropy_pool()
-
-    # Déterminer le nombre optimal de processus
-    num_processes = min(os.cpu_count() or 4, 4)  # Limiter à un nombre raisonnable
-
-    # Répartir le travail entre les processus
-    tirages_par_processus = num_tirages // num_processes
-    remainder = num_tirages % num_processes
-
-    # Préparer les tâches pour chaque processus
-    tasks = []
-    for i in range(num_processes):
-        count = tirages_par_processus + (1 if i < remainder else 0)
-        if count > 0:
-            tasks.append((count, base_pool))
-
     bar = Bar('Progression', max=num_tirages, suffix='%(percent)d%%')
 
-    # Exécuter les tâches en parallèle
     tirages = []
-    with ProcessPoolExecutor(max_workers=num_processes) as executor:
+    for _ in range(num_tirages):
-        futures = [executor.submit(worker_process, count, bp) for count, bp in tasks]
+        tirages.append(faire_tirage(base_pool))
-        for future in futures:
+        time.sleep(0.01)
-            batch = future.result()
+        bar.next()
-            tirages.extend(batch)
-            bar.next(len(batch))
 
     bar.finish()
     return tirages
 
-if __name__ == "__main__":
+def afficher_tirage(tirage, indice=None, titre="TIRAGE"):
-    print("Génération de 100 tirages différents...")
+    """Affiche un tirage de façon formatée"""
-    tirages = generate_draws(100)
+    print(f"\n===== {titre} =====")
+    if indice is not None:
+        print(f"Tirage #{indice + 1}")
+    print(f"Numéros : {tirage['numeros']}")
+    print(f"Étoiles : {tirage['etoiles']}")
+    print(f"Graine utilisée : {tirage['graine']}")
 
-    # Mélange final pour le choix du tirage avec une nouvelle graine
+def afficher_tirages_supplementaires(tirages, tirages_affiches):
-    base_pool = initialize_entropy_pool()
+    """Affiche des tirages aléatoires supplémentaires à la demande de l'utilisateur."""
+    while len(tirages_affiches) < len(tirages):
+        afficher_autre = input("\nVoulez-vous voir un autre tirage aléatoire? (o/n): ").lower().strip()
+        if afficher_autre not in ['o', 'oui', 'y', 'yes', '']:
+            break
+
+        indices_disponibles = [i for i in range(len(tirages)) if i not in tirages_affiches]
+        if not indices_disponibles:
+            print("Tous les tirages ont déjà été affichés!")
+            break
+
+        indice_nouveau = random.choice(indices_disponibles)
+        nouveau_tirage = tirages[indice_nouveau]
+        tirages_affiches.add(indice_nouveau)
+
+        afficher_tirage(nouveau_tirage, indice_nouveau, "AUTRE TIRAGE ALÉATOIRE")
+
+if __name__ == "__main__":
+    print(f"Génération de {NOMBRE_TIRAGE} tirages différents...")
+    tirages = generate_draws(NOMBRE_TIRAGE)
+
+    base_pool = get_static_entropy_pool()
     random.seed(generate_seed(base_pool))
     tirage_choisi = random.choice(tirages)
+    tirages_affiches = {tirages.index(tirage_choisi)}
 
-    print("\n===== RÉSULTAT FINAL =====")
+    afficher_tirage(tirage_choisi, titre="RÉSULTAT FINAL")
-    print("Tirage sélectionné parmi les 100 générés")
+    print("Tirage sélectionné parmi les", NOMBRE_TIRAGE, "générés")
-    print("Graine utilisée :", tirage_choisi["graine"])
+    afficher_tirages_supplementaires(tirages, tirages_affiches)
-    print("Numéros :", tirage_choisi["numeros"])
-    print("Étoiles :", tirage_choisi["etoiles"])
-
-    # Demander à l'utilisateur s'il souhaite afficher tous les tirages
-    afficher_tous = input("\nVoulez-vous afficher tous les tirages générés? (o/n): ").lower().strip()
-    if afficher_tous in ['o', 'oui', 'y', 'yes']:
-        print("\n===== TOUS LES TIRAGES =====")
-        for i, tirage in enumerate(tirages, 1):
-            print(f"Tirage {i}:")
-            print(f"  Numéros: {tirage['numeros']}")
-            print(f"  Étoiles: {tirage['etoiles']}")
-            print(f"  Graine: {tirage['graine']}")
-            print("-" * 30)
-
-    input("\nAppuyez sur Entrée pour quitter...")

requirements.txt

@@ -4,3 +4,4 @@ progress==1.6
 psutil==7.0.0
 requests-cache==1.2.1
 retry-requests==2.0.0
+numpy==2.2.4