my_code_python

Code mostly in Python to use at your risk!

# ===  Étape 0: Configuration Complète # ===
# =======================================#

# === Cellule 0: Configuration Complète (Tout-en-un) ===
# Installe Java 21, configure comme défaut, installe outils build,
# pybind11, dernière Pyserini, NLTK+ressources, définit chemins, fonctions, parse topics.

import os
import sys
import subprocess
import time
import glob
import re
import json
import nltk # Importer nltk ici pour la partie NLTK
from tqdm.notebook import tqdm # Assurer l'import pour les fonctions
import traceback # Pour afficher les erreurs

print("--- Début de la Configuration Complète ---")
print("Cela peut prendre plusieurs minutes...")

# --- Partie 1: Installation Java 21 et Configuration ---
print("\n[1/9] Installation de OpenJDK 21...")
install_java_cmd = "apt-get update -qq &gt; /dev/null &amp;&amp; apt-get install -y openjdk-21-jdk-headless -qq &gt; /dev/null"
try:
    subprocess.run(install_java_cmd, shell=True, check=True, timeout=180)
    print("OpenJDK 21 installé.")
except Exception as e:
    print(f"ERREUR lors de l'installation de Java 21: {e}")
    raise

print("\n[2/9] Configuration de Java 21 comme défaut via update-alternatives...")
java_path_21 = "/usr/lib/jvm/java-21-openjdk-amd64/bin/java"
if os.path.exists(java_path_21):
    try:
        subprocess.run(f"update-alternatives --install /usr/bin/java java {java_path_21} 1", shell=True, check=True)
        subprocess.run(f"update-alternatives --set java {java_path_21}", shell=True, check=True)
        print("update-alternatives configuré pour java.")
    except Exception as e:
        print(f"ERREUR lors de la configuration de update-alternatives: {e}")
else:
    print(f"ATTENTION: Chemin Java 21 non trouvé à {java_path_21}. update-alternatives non configuré.")
os.environ["JAVA_HOME"] = "/usr/lib/jvm/java-21-openjdk-amd64"
if not os.path.exists(os.environ["JAVA_HOME"]):
     print(f"ATTENTION: Le chemin JAVA_HOME '{os.environ['JAVA_HOME']}' n'existe pas.")

# --- Partie 2: Installation des outils de build C++ ---
print("\n[3/9] Installation des outils de build (build-essential, cmake)...")
install_build_cmd = "apt-get update -qq &gt; /dev/null &amp;&amp; apt-get install -y build-essential cmake -qq &gt; /dev/null"
try:
    subprocess.run(install_build_cmd, shell=True, check=True, timeout=180)
    print("Outils de build installés.")
except Exception as e_build:
    print(f"ERREUR lors de l'installation des outils de build: {e_build}")

# --- Partie 3: Installation de pybind11 ---
print("\n[4/9] Installation de pybind11...")
install_pybind_cmd = f"{sys.executable} -m pip install pybind11 -q"
try:
    subprocess.run(install_pybind_cmd, shell=True, check=True, capture_output=True, text=True, timeout=60)
    print("pybind11 installé avec succès.")
except Exception as e_pybind:
    print(f"ERREUR lors de l'installation de pybind11: {e_pybind}")

# --- Partie 4: Installation des Paquets Python Principaux ---
print("\n[5/9] Installation de la DERNIÈRE Pyserini, NLTK, Pytrec_eval...")
install_pip_cmd = f"{sys.executable} -m pip install pyserini nltk pytrec_eval"
try:
    result_pip = subprocess.run(install_pip_cmd, shell=True, check=True, capture_output=True, text=True, timeout=600)
    print("Paquets Python principaux installés.")
except subprocess.CalledProcessError as e:
    print(f"\nERREUR: La commande pip principale a échoué avec le code {e.returncode}")
    print("Sortie STDOUT de Pip:\n", e.stdout)
    print("Sortie STDERR de Pip:\n", e.stderr)
    raise e
except subprocess.TimeoutExpired as e:
    print("\nERREUR: La commande pip principale a dépassé le délai d'attente.")
    print("Sortie STDOUT de Pip (partielle):\n", e.stdout)
    print("Sortie STDERR de Pip (partielle):\n", e.stderr)
    raise e
except Exception as e_pip:
    print(f"\nERREUR inattendue lors de l'installation pip: {e_pip}")
    raise e_pip

# --- Partie 5: Téléchargement Ressources NLTK ---
print("\n[6/9] Téléchargement/Vérification des ressources NLTK...")
import nltk
nltk_resources = ['wordnet', 'stopwords', 'punkt', 'omw-1.4', 'punkt_tab'] # Liste corrigée
for resource in nltk_resources:
    try:
        if resource == 'punkt' or resource == 'punkt_tab':
            resource_path = f'tokenizers/{resource}.zip'
        elif resource == 'omw-1.4':
             resource_path = f'corpora/{resource}.zip'
        elif resource == 'wordnet':
             resource_path = f'corpora/{resource}.zip'
        else:
            resource_path = f'corpora/{resource}.zip'
        nltk.data.find(resource_path)
    except LookupError: # Gestion d'erreur corrigée
        print(f"  Ressource NLTK '{resource}' non trouvée. Téléchargement...")
        try:
            nltk.download(resource, quiet=True)
            print(f"  Ressource '{resource}' téléchargée.")
        except Exception as e_download:
            print(f"  ERREUR lors du téléchargement de '{resource}': {e_download}")
print("Ressources NLTK prêtes.")

# --- Partie 6: Définition des Chemins ---
print("\n[7/9] Définition des chemins...")

# !!! MODIFIEZ CETTE LIGNE AVEC LE CHEMIN CORRECT VERS VOTRE DOSSIER TREC !!!
DRIVE_PROJECT_PATH = "/content/drive/My Drive/Projet_RI/TREC" # &lt;--- VÉRIFIEZ ET CORRIGEZ CE CHEMIN !

# --- Vérification et définition des autres chemins ---
if 'google.colab' in sys.modules:
    try:
        from google.colab import drive
        if not os.path.exists('/content/drive/My Drive'):
             print("  Montage de Google Drive...")
             drive.mount('/content/drive', force_remount=True)
        else:
             print("  Google Drive déjà monté.")
    except Exception as e_mount:
         print(f"ATTENTION: Erreur lors du montage de Drive: {e_mount}")

if not os.path.exists(DRIVE_PROJECT_PATH):
     raise FileNotFoundError(f"Le chemin Drive '{DRIVE_PROJECT_PATH}' n'existe pas.")

print(f"  Chemin du projet Drive utilisé: {DRIVE_PROJECT_PATH}")

AP_TAR_FILENAME = "AP.tar" # Nom du fichier archive (corrigé)
AP_TAR_PATH = os.path.join(DRIVE_PROJECT_PATH, AP_TAR_FILENAME)
TOPICS_DIR = os.path.join(DRIVE_PROJECT_PATH, "Topics-requetes")
QRELS_DIR = os.path.join(DRIVE_PROJECT_PATH, "jugements de pertinence")
OUTPUT_DIR = "/content/ap_output"
INDEX_DIR_BASELINE = os.path.join(OUTPUT_DIR, "indexes/baseline")
INDEX_DIR_PREPROC = os.path.join(OUTPUT_DIR, "indexes/preprocessed")
CORPUS_DIR = os.path.join(OUTPUT_DIR, "corpus")
RUN_DIR = os.path.join(OUTPUT_DIR, "runs")
EVAL_DIR = os.path.join(OUTPUT_DIR, "eval")
os.makedirs(OUTPUT_DIR, exist_ok=True)
os.makedirs(INDEX_DIR_BASELINE, exist_ok=True)
os.makedirs(INDEX_DIR_PREPROC, exist_ok=True)
os.makedirs(CORPUS_DIR, exist_ok=True)
os.makedirs(RUN_DIR, exist_ok=True)
os.makedirs(EVAL_DIR, exist_ok=True)
print(f"  Chemin Fichier AP CIBLE: {AP_TAR_PATH}")
print(f"  Chemin Qrels: {QRELS_DIR}")
print(f"  Chemin Runs: {RUN_DIR}")

# --- Partie 7: Définition Fonction Prétraitement ---
print("\n[8/9] Définition de la fonction preprocess_text...")
import nltk
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
from nltk.tokenize import word_tokenize
import string
stop_words_set_global = set(stopwords.words('english'))
lemmatizer_obj_global = WordNetLemmatizer()
def preprocess_text(text):
    """Applique la tokenisation, la mise en minuscule, la suppression de la ponctuation, la suppression des stop words et la lemmatisation."""
    if not isinstance(text, str): return ""
    try:
        tokens = word_tokenize(text.lower())
    except LookupError as e_tok:
         if 'Resource' in str(e_tok) and 'not found' in str(e_tok):
              resource_name = str(e_tok).split('Resource ')[1].split(' ')[0]
              print(f"--- Tokenizer a besoin de '{resource_name}', tentative de téléchargement ---")
              try:
                  nltk.download(resource_name, quiet=True)
                  print(f"--- Ressource '{resource_name}' téléchargée, nouvelle tentative de tokenisation ---")
                  tokens = word_tokenize(text.lower())
              except Exception as e_dl_tok:
                  print(f"--- Échec du téléchargement de '{resource_name}': {e_dl_tok} ---")
                  raise e_tok
         else: raise e_tok
    except Exception as e_tok_other:
         print(f"Erreur inattendue dans word_tokenize: {e_tok_other}")
         raise e_tok_other
    filtered_tokens = [lemmatizer_obj_global.lemmatize(w) for w in tokens if w.isalpha() and w not in stop_words_set_global]
    return ' '.join(filtered_tokens)
print("  Fonction preprocess_text définie.")

# --- Partie 8: Parsing des Topics ---
print("\n[9/9] Parsing des topics...")
import re
import glob
def parse_topics(file_path):
    """Parse un fichier topic TREC standard."""
    topics = {}
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            content = f.read()
            for top_match in re.finditer(r"&lt;top&gt;(.*?)&lt;/top&gt;", content, re.DOTALL):
                topic_content = top_match.group(1)
                num_match = re.search(r"&lt;num&gt;\s*Number:\s*(\d+)", topic_content, re.IGNORECASE)
                if not num_match: continue
                topic_id = num_match.group(1).strip()
                title_match = re.search(r"&lt;title&gt;\s*(.*?)\s*(?=&lt;|$)", topic_content, re.IGNORECASE | re.DOTALL)
                title = title_match.group(1).strip() if title_match else ""
                desc_match = re.search(r"&lt;desc&gt;\s*Description:\s*(.*?)\s*(?=&lt;|$)", topic_content, re.IGNORECASE | re.DOTALL)
                desc = desc_match.group(1).strip() if desc_match else ""
                if topic_id and title: topics[topic_id] = {'title': title, 'desc': desc}
    except FileNotFoundError: print(f"  ATTENTION: Fichier topic non trouvé: {file_path}")
    except Exception as e_topic: print(f"  ATTENTION: Erreur parsing {file_path}: {e_topic}")
    return topics

if not os.path.exists(TOPICS_DIR):
     print(f"ATTENTION: Le dossier des topics '{TOPICS_DIR}' n'existe pas.")
     topic_files = []
else: topic_files = sorted(glob.glob(os.path.join(TOPICS_DIR, "topics.*.txt")))
all_topics = {}
if not topic_files: print(f"  ATTENTION: Aucun fichier topic trouvé dans {TOPICS_DIR}")
else:
    print(f"  Parsing des fichiers topics: {topic_files}")
    for tf in topic_files: all_topics.update(parse_topics(tf))

try:
    queries_short = {qid: data['title'] for qid, data in all_topics.items()}
    queries_long = {qid: data['title'] + " " + data['desc'] for qid, data in all_topics.items()}
    print(f"  {len(all_topics)} topics parsés.")
    print(f"  {len(queries_short)} requêtes courtes brutes créées.")
    print(f"  Prétraitement des requêtes...")
    queries_short_preprocessed = {qid: preprocess_text(q) for qid, q in queries_short.items()}
    queries_long_preprocessed = {qid: preprocess_text(q) for qid, q in queries_long.items()}
    print(f"  Prétraitement des requêtes terminé.")
except Exception as e_preproc_queries:
     print(f"\nERREUR lors du prétraitement des requêtes: {e_preproc_queries}")
     queries_short_preprocessed, queries_long_preprocessed = {}, {}

# --- Vérification Finale Java ---
print("\n--- Vérification Finale de la Version Java Active ---")
java_check_cmd = "java -version"
try:
    result = subprocess.run(java_check_cmd, shell=True, check=True, capture_output=True, text=True, timeout=10)
    print("Sortie STDERR (contient souvent la version OpenJDK):\n", result.stderr)
    if "21." not in result.stderr and "21." not in result.stdout: print("\nATTENTION: Java 21 ne semble PAS être la version active !")
    else: print("\nConfirmation: Java 21 semble être la version active.")
except Exception as e: print(f"\nERREUR lors de la vérification Java: {e}")

# --- Vérification Finale Pyserini ---
print("\n--- Vérification Finale de la Version Pyserini Installée ---")
try:
    result_pyserini = subprocess.run(f"{sys.executable} -m pip show pyserini", shell=True, check=True, capture_output=True, text=True, timeout=30)
    print(result_pyserini.stdout)
except Exception as e_pyserini_check: print(f"ERREUR lors de la vérification de Pyserini: {e_pyserini_check}")

print("\n--- Configuration Complète Terminée ---")
print("\nPause de 5 secondes...")
time.sleep(5)
print("Prêt pour la suite.")

# --- Nouvelle Cellule ---

# === Cellule 1: Extraire, Décompresser et Formater les Documents ===
# Lit AP.tar, décompresse les .gz internes, extrait &lt;DOC&gt;, &lt;DOCNO&gt;, &lt;TEXT&gt;
# et écrit le résultat dans ap_docs.jsonl.

import tarfile
import re
import json
import gzip # Module pour décompresser
from tqdm.notebook import tqdm
import os
import traceback

# Vérifier que les chemins sont définis
try:
    AP_TAR_PATH
    CORPUS_DIR
except NameError:
    print("ERREUR: Variables de chemin non définies. Exécutez la cellule de configuration complète.")
    raise

JSONL_OUTPUT_PATH = os.path.join(CORPUS_DIR, "ap_docs.jsonl")

print(f"Extraction, Décompression et Formatage depuis {AP_TAR_PATH} vers {JSONL_OUTPUT_PATH}...")

# Vérifier si le fichier AP.tar existe
if not os.path.exists(AP_TAR_PATH):
    raise FileNotFoundError(f"Le fichier d'archive {AP_TAR_PATH} n'a pas été trouvé.")
else:
    tar_size = os.path.getsize(AP_TAR_PATH)
    print(f"  Taille du fichier {AP_TAR_PATH}: {tar_size} octets.")

# Regex pour extraire les infos
doc_pattern = re.compile(r"&lt;DOC&gt;(.*?)&lt;/DOC&gt;", re.DOTALL)
docno_pattern = re.compile(r"&lt;DOCNO&gt;\s*(.*?)\s*&lt;/DOCNO&gt;")
text_pattern = re.compile(r"&lt;TEXT&gt;(.*?)&lt;/TEXT&gt;", re.DOTALL)

# Compteurs
doc_count = 0
file_read_count = 0
skipped_members = 0
decompression_errors = 0

try:
    # Ouvrir le fichier de sortie et l'archive TAR
    with open(JSONL_OUTPUT_PATH, 'w', encoding='utf-8') as outfile, tarfile.open(AP_TAR_PATH, "r:") as tar:
        members = tar.getmembers()
        print(f"\n{len(members)} membres trouvés dans l'archive TAR.")

        # Boucler sur chaque membre de l'archive
        for member in tqdm(members, desc="Traitement des fichiers TAR"):
            # Ignorer si ce n'est pas un fichier .gz ou .Z
            if not member.isfile() or not member.name.lower().endswith(('.gz', '.z')):
                skipped_members += 1
                continue

            file_read_count += 1
            content = "" # Réinitialiser pour chaque fichier

            try:
                # Extraire le contenu compressé
                f = tar.extractfile(member)
                if f:
                    compressed_content = f.read()
                    f.close()

                    # Décompresser le contenu
                    try:
                        content_bytes = gzip.decompress(compressed_content)
                        content = content_bytes.decode('utf-8', errors='ignore') # Décoder après décompression
                    except gzip.BadGzipFile: # Gérer si ce n'est pas du gzip
                        content = compressed_content.decode('utf-8', errors='ignore')
                        decompression_errors += 1
                    except Exception as e_gzip:
                         print(f"\nErreur de décompression pour {member.name}: {e_gzip}")
                         decompression_errors += 1
                         continue # Passer au suivant

                    # Trouver tous les blocs &lt;DOC&gt; dans le contenu décompressé
                    doc_matches = doc_pattern.findall(content)
                    if not doc_matches: continue # Passer si aucun doc trouvé

                    # Boucler sur chaque document trouvé
                    for doc_content in doc_matches:
                        docno_match = docno_pattern.search(doc_content)
                        if not docno_match: continue
                        doc_id = docno_match.group(1).strip()

                        text_match = text_pattern.search(doc_content)
                        # Nettoyer le texte (espaces multiples)
                        doc_text = ' '.join(text_match.group(1).strip().split()) if text_match else ""

                        # Écrire la ligne JSONL
                        try:
                            json_line = json.dumps({"id": str(doc_id), "contents": str(doc_text)})
                            outfile.write(json_line + '\n')
                            doc_count += 1
                        except Exception as e_write:
                            print(f"Erreur écriture JSON pour doc_id {doc_id}: {e_write}")

            except KeyError as e_key: print(f"\nAvertissement: Membre '{member.name}' inaccessible (KeyError): {e_key}"); skipped_members += 1
            except EOFError: print(f"\nAvertissement: Fin fichier inattendue {member.name}."); skipped_members += 1
            except Exception as e_extract: print(f"\nErreur extraction/lecture {member.name}: {e_extract}"); skipped_members += 1

except tarfile.ReadError as e_tar: print(f"\nERREUR lecture TAR {AP_TAR_PATH}: {e_tar}"); raise e_tar
except FileNotFoundError: print(f"\nERREUR: Fichier TAR {AP_TAR_PATH} non trouvé."); raise FileNotFoundError
except Exception as e_general: print(f"\nERREUR générale traitement TAR: {e_general}"); traceback.print_exc(); raise e_general

# Afficher le résumé de l'extraction
print(f"\n--- Fin de l'Extraction et Décompression ---")
print(f"  {file_read_count} fichiers (.gz/.Z) lus.")
print(f"  {skipped_members} membres ignorés.")
if decompression_errors &gt; 0: print(f"  {decompression_errors} erreurs/avertissements décompression.")
print(f"  {doc_count} documents écrits dans {JSONL_OUTPUT_PATH}")

# Vérifier la taille du fichier de sortie
if os.path.exists(JSONL_OUTPUT_PATH):
    output_size = os.path.getsize(JSONL_OUTPUT_PATH)
    print(f"  Taille finale {JSONL_OUTPUT_PATH}: {output_size} octets.")
    if output_size &gt; 0 and doc_count &gt; 0: print("  SUCCÈS: Fichier de sortie contient des données.")
    else: print("  ATTENTION: Fichier de sortie vide ou aucun document écrit.")
else: print(f"  ATTENTION: Fichier {JSONL_OUTPUT_PATH} non créé.")



# --- Nouvelle Cellule ---

# === Cellule 2: Indexation Baseline ===
# Crée l'index Lucene à partir de ap_docs.jsonl (sans prétraitement spécifique).

import os
import subprocess
import traceback

# Vérifier que les chemins sont définis
try:
    CORPUS_DIR
    INDEX_DIR_BASELINE
except NameError:
    print("ERREUR: Variables de chemin non définies. Exécutez la cellule de configuration complète.")
    raise

print(f"Début de l'indexation Baseline...")
print(f"Dossier source: {CORPUS_DIR}")
print(f"Répertoire de l'index cible: {INDEX_DIR_BASELINE}")

# Vérifier si le fichier source existe et n'est pas vide
jsonl_source_path = os.path.join(CORPUS_DIR, "ap_docs.jsonl")
if not os.path.exists(jsonl_source_path) or os.path.getsize(jsonl_source_path) == 0:
     raise FileNotFoundError(f"Le fichier source {jsonl_source_path} est manquant ou vide.")

# Commande Pyserini
index_cmd_baseline = [
    "python", "-m", "pyserini.index.lucene",
    "--collection", "JsonCollection",
    "--input", CORPUS_DIR,
    "--index", INDEX_DIR_BASELINE,
    "--generator", "DefaultLuceneDocumentGenerator",
    "--threads", "4",
    "--storePositions", "--storeDocvectors", "--storeRaw"
]

print(f"Exécution: {' '.join(index_cmd_baseline)}")
try:
    # Exécuter la commande d'indexation
    result = subprocess.run(index_cmd_baseline, check=True, capture_output=True, text=True, timeout=1800) # Timeout 30 min
    print("Sortie STDOUT (fin):\n", result.stdout[-1000:]) # Afficher la fin de stdout
    print("Sortie STDERR:\n", result.stderr)
    if "Total 0 documents indexed" in result.stdout:
         print("\nATTENTION: Pyserini indique 0 document indexé.")
    else:
         print(f"\nIndexation Baseline terminée. Index créé dans {INDEX_DIR_BASELINE}")
except Exception as e:
    # Gérer les erreurs potentielles
    print(f"\nERREUR pendant l'indexation Baseline: {e}")
    if isinstance(e, subprocess.CalledProcessError):
        print("Sortie STDOUT:\n", e.stdout)
        print("Sortie STDERR:\n", e.stderr)
    else:
        traceback.print_exc()
    raise e

# Vérifier la taille de l'index créé
print(f"\nVérification taille index: {INDEX_DIR_BASELINE}...")
if os.path.exists(INDEX_DIR_BASELINE):
    du_cmd = f"du -sh '{INDEX_DIR_BASELINE}'"
    try:
        result_du = subprocess.run(du_cmd, shell=True, check=True, capture_output=True, text=True)
        print(f"  Taille: {result_du.stdout.split()[0]}")
    except Exception as e_du:
        print(f"  Impossible de vérifier taille: {e_du}")
else:
    print("  ATTENTION: Dossier index non créé.")


# --- Nouvelle Cellule ---

# === Cellule 3: Préparer les Données Prétraitées ===
# Lit ap_docs.jsonl, applique la fonction preprocess_text (lemmatisation, etc.)
# et écrit le résultat dans ap_docs_preprocessed.jsonl.

import json
from tqdm.notebook import tqdm
import os
import traceback

# Vérifier que les chemins et la fonction sont définis
try:
    CORPUS_DIR
    JSONL_OUTPUT_PATH # Défini dans la config, utilisé comme entrée ici
    preprocess_text # Défini dans la config
except NameError:
    print("ERREUR: Variables/Fonction non définies. Exécutez la cellule de configuration complète.")
    raise

JSONL_PREPROC_PATH = os.path.join(CORPUS_DIR, "ap_docs_preprocessed.jsonl") # Fichier de sortie

print(f"Préparation données prétraitées depuis {JSONL_OUTPUT_PATH} vers {JSONL_PREPROC_PATH}...")

# Vérifier fichier source
if not os.path.exists(JSONL_OUTPUT_PATH) or os.path.getsize(JSONL_OUTPUT_PATH) == 0:
     raise FileNotFoundError(f"Le fichier source {JSONL_OUTPUT_PATH} est manquant ou vide.")

doc_count_preproc = 0
error_count = 0
try:
    # Ouvrir les fichiers d'entrée et de sortie
    with open(JSONL_OUTPUT_PATH, 'r', encoding='utf-8') as infile, \
         open(JSONL_PREPROC_PATH, 'w', encoding='utf-8') as outfile:
        # Boucler sur chaque ligne du fichier d'entrée
        for line in tqdm(infile, desc="Prétraitement des documents"):
            try:
                data = json.loads(line)
                doc_id = data.get('id', None)
                original_contents = data.get('contents', '')
                if doc_id is None: error_count += 1; continue

                # Appliquer le prétraitement
                preprocessed_contents = preprocess_text(original_contents)

                # Écrire la ligne traitée
                json_line = json.dumps({"id": str(doc_id), "contents": str(preprocessed_contents)})
                outfile.write(json_line + '\n')
                doc_count_preproc += 1
            except json.JSONDecodeError: error_count += 1 # Compter les erreurs JSON
            except Exception as e_line: print(f"\nErreur ligne (id={data.get('id', 'inconnu')}): {e_line}"); error_count += 1

    # Afficher le résumé
    print(f"\nTerminé.")
    print(f"  {doc_count_preproc} documents prétraités écrits dans {JSONL_PREPROC_PATH}")
    if error_count &gt; 0: print(f"  {error_count} lignes ignorées.")

    # Vérifier la taille du fichier de sortie
    if os.path.exists(JSONL_PREPROC_PATH):
        output_size = os.path.getsize(JSONL_PREPROC_PATH)
        print(f"  Taille finale: {output_size} octets.")
        if output_size == 0 and doc_count_preproc &gt; 0: print("  ATTENTION: Taille nulle ?!")
    else: print(f"  ATTENTION: Fichier sortie {JSONL_PREPROC_PATH} non créé.")

except Exception as e_main:
    print(f"ERREUR générale préparation données prétraitées: {e_main}")
    traceback.print_exc()
    raise


# --- Nouvelle Cellule ---

# === Cellule 4: Indexation Prétraitée ===
# Crée l'index Lucene à partir de ap_docs_preprocessed.jsonl.
# Utilise l'option --pretokenized car le texte est déjà traité.

import os
import subprocess
import traceback

# Vérifier que les chemins sont définis
try:
    CORPUS_DIR
    INDEX_DIR_PREPROC
except NameError:
    print("ERREUR: Variables de chemin non définies. Exécutez la cellule de configuration complète.")
    raise

JSONL_PREPROC_PATH = os.path.join(CORPUS_DIR, "ap_docs_preprocessed.jsonl") # Fichier source

print(f"Début de l'indexation Prétraitée...")
print(f"Collection source (dossier): {CORPUS_DIR}")
print(f"Fichier JSONL prétraité attendu: {JSONL_PREPROC_PATH}")
print(f"Répertoire de l'index cible: {INDEX_DIR_PREPROC}")

# Vérifier si le fichier prétraité existe et n'est pas vide
if not os.path.exists(JSONL_PREPROC_PATH) or os.path.getsize(JSONL_PREPROC_PATH) == 0:
    raise FileNotFoundError(f"Le fichier données prétraitées {JSONL_PREPROC_PATH} est manquant ou vide.")

# Commande Pyserini
index_cmd_preproc = [
    "python", "-m", "pyserini.index.lucene",
    "--collection", "JsonCollection",
    "--input", CORPUS_DIR,
    "--index", INDEX_DIR_PREPROC,
    "--generator", "DefaultLuceneDocumentGenerator",
    "--threads", "4",
    "--storePositions", "--storeDocvectors", "--storeRaw",
    "--pretokenized" # Option clé ici
]

print(f"Exécution: {' '.join(index_cmd_preproc)}")
try:
    # Exécuter la commande d'indexation
    result = subprocess.run(index_cmd_preproc, check=True, capture_output=True, text=True, timeout=1800) # Timeout 30 min
    print("Sortie STDOUT (fin):\n", result.stdout[-1000:])
    print("Sortie STDERR:\n", result.stderr)
    if "Total 0 documents indexed" in result.stdout:
         print("\nATTENTION: Pyserini indique 0 document indexé.")
    else:
        print(f"\nIndexation Prétraitée terminée. Index créé dans {INDEX_DIR_PREPROC}")
except Exception as e:
    # Gérer les erreurs
    print(f"\nERREUR pendant l'indexation Prétraitée: {e}")
    if isinstance(e, subprocess.CalledProcessError):
        print("Sortie STDOUT:\n", e.stdout)
        print("Sortie STDERR:\n", e.stderr)
    else:
        traceback.print_exc()
    raise e

# Vérifier la taille de l'index
print(f"\nVérification taille index: {INDEX_DIR_PREPROC}...")
if os.path.exists(INDEX_DIR_PREPROC):
    du_cmd = f"du -sh '{INDEX_DIR_PREPROC}'"
    try:
        result_du = subprocess.run(du_cmd, shell=True, check=True, capture_output=True, text=True)
        print(f"  Taille: {result_du.stdout.split()[0]}")
    except Exception as e_du:
        print(f"  Impossible de vérifier taille: {e_du}")
else:
    print("  ATTENTION: Dossier index non créé.")



# --- Nouvelle Cellule ---

# === Cellule 5: Exécuter les Recherches (Séquentielles - BM25 &amp; TF-IDF) ===
# Lance les 8 combinaisons de recherche et sauvegarde les résultats.
# Assurez-vous que l'environnement Java 21 est toujours actif.

from pyserini.search.lucene import LuceneSearcher # Import principal
import time
from tqdm.notebook import tqdm
import traceback
import os
from jnius import autoclass, JavaException # Pour TF-IDF

# Définir K_RESULTS
try: K_RESULTS
except NameError: print("Définition K_RESULTS=1000"); K_RESULTS = 1000

# Charger ClassicSimilarity
try: ClassicSimilarity = autoclass('org.apache.lucene.search.similarities.ClassicSimilarity'); print("ClassicSimilarity chargée.")
except Exception as e: print(f"ERREUR chargement ClassicSimilarity: {e}"); ClassicSimilarity = None

# Vérifier variables nécessaires
try:
    INDEX_DIR_BASELINE; INDEX_DIR_PREPROC; RUN_DIR; K_RESULTS;
    queries_short; queries_long; queries_short_preprocessed; queries_long_preprocessed;
    preprocess_text;
except NameError as e: print(f"ERREUR: Variable {e} manquante. Exécutez config complète."); raise

# Fonction de recherche (inchangée par rapport à la version précédente fonctionnelle)
def perform_search_sequential(queries, index_path, model, k, output_run_file, run_tag_prefix, use_preprocessed_query=False):
    start_time = time.time()
    run_tag = f"{run_tag_prefix}_{model}"
    print(f"\nDébut recherche SÉQUENTIELLE: Index='{os.path.basename(index_path)}', Modèle='{model}', Tag='{run_tag}', k={k}")
    all_results_list = []
    searcher = None
    try:
        print(f"  Initialisation LuceneSearcher..."); searcher = LuceneSearcher(index_path); print(f"  LuceneSearcher initialisé.")
        if model == 'bm25': print("  Config BM25..."); searcher.set_bm25(k1=0.9, b=0.4); print("  BM25 configuré.")
        elif model == 'tfidf':
            if ClassicSimilarity is None: print("ERREUR: ClassicSimilarity non chargée. ABANDON."); return
            print("  Config ClassicSimilarity (TF-IDF)...")
            try: searcher.set_similarity(ClassicSimilarity()); print("  ClassicSimilarity configurée.")
            except Exception as e_sim: print(f"ERREUR config ClassicSimilarity: {e_sim}"); return
        else: print(f"Modèle '{model}' non reconnu, utilise BM25."); searcher.set_bm25()

        query_errors = 0
        for query_id, query_text in tqdm(queries.items(), desc=f"Recherche {run_tag}"):
            try:
                search_text = preprocess_text(query_text) if use_preprocessed_query else query_text
                if not search_text.strip(): continue
                hits = searcher.search(search_text, k=k)
                for i in range(len(hits)):
                    rank, doc_id, score = i + 1, hits[i].docid, hits[i].score
                    if doc_id is None: continue
                    all_results_list.append(f"{query_id} Q0 {doc_id} {rank} {score:.6f} {run_tag}\n")
            except Exception as e_query:
                query_errors += 1
                if query_errors &lt; 5: print(f"\nErreur recherche QID {query_id}: {e_query}")
                elif query_errors == 5: print("\nPlusieurs erreurs recherche...")

        if all_results_list:
             with open(output_run_file, 'w', encoding='utf-8') as f_out: f_out.writelines(all_results_list)
             print(f"\n  {len(all_results_list)} lignes résultats écrites.")
        else: print("\n  Avertissement: Aucun résultat généré.")
        if query_errors &gt; 0: print(f"  Avertissement: {query_errors} erreurs sur requêtes.")
        end_time = time.time()
        print(f"Recherche terminée pour {run_tag}. Sauvegardé dans {output_run_file}")
        print(f"Temps écoulé: {end_time - start_time:.2f} secondes.")
    except Exception as e_main: print(f"\nERREUR MAJEURE run {run_tag}: {e_main}"); traceback.print_exc()
    finally:
        if searcher: print(f"  Nettoyage implicite ressources {run_tag}.")

# --- Exécution des 8 configurations ---
print("\n--- DÉBUT DES RECHERCHES BASELINE ---")
run_file_1 = os.path.join(RUN_DIR, "baseline_short_bm25.txt"); perform_search_sequential(queries_short, INDEX_DIR_BASELINE, 'bm25', K_RESULTS, run_file_1, "baseline_short")
run_file_2 = os.path.join(RUN_DIR, "baseline_short_tfidf.txt"); perform_search_sequential(queries_short, INDEX_DIR_BASELINE, 'tfidf', K_RESULTS, run_file_2, "baseline_short")
run_file_3 = os.path.join(RUN_DIR, "baseline_long_bm25.txt"); perform_search_sequential(queries_long, INDEX_DIR_BASELINE, 'bm25', K_RESULTS, run_file_3, "baseline_long")
run_file_4 = os.path.join(RUN_DIR, "baseline_long_tfidf.txt"); perform_search_sequential(queries_long, INDEX_DIR_BASELINE, 'tfidf', K_RESULTS, run_file_4, "baseline_long")
print("\n--- DÉBUT DES RECHERCHES PRÉTRAITÉES ---")
run_file_5 = os.path.join(RUN_DIR, "preproc_short_bm25.txt"); perform_search_sequential(queries_short_preprocessed, INDEX_DIR_PREPROC, 'bm25', K_RESULTS, run_file_5, "preproc_short", use_preprocessed_query=False)
run_file_6 = os.path.join(RUN_DIR, "preproc_short_tfidf.txt"); perform_search_sequential(queries_short_preprocessed, INDEX_DIR_PREPROC, 'tfidf', K_RESULTS, run_file_6, "preproc_short", use_preprocessed_query=False)
run_file_7 = os.path.join(RUN_DIR, "preproc_long_bm25.txt"); perform_search_sequential(queries_long_preprocessed, INDEX_DIR_PREPROC, 'bm25', K_RESULTS, run_file_7, "preproc_long", use_preprocessed_query=False)
run_file_8 = os.path.join(RUN_DIR, "preproc_long_tfidf.txt"); perform_search_sequential(queries_long_preprocessed, INDEX_DIR_PREPROC, 'tfidf', K_RESULTS, run_file_8, "preproc_long", use_preprocessed_query=False)
print("\n--- Toutes les recherches de base (mode séquentiel) sont terminées. ---")



# --- Nouvelle Cellule ---

# === Cellule 6: Évaluation des Runs (Partie 1 et/ou Finale) ===
# Lit les fichiers Qrels, lit les fichiers de résultats (.txt) du dossier RUN_DIR,
# calcule MAP et P@10, et affiche/sauvegarde les tableaux récapitulatifs.
# Peut être exécutée après l'étape 5 (Recherche) et ré-exécutée après l'étape 7 (RM3).

import pandas as pd
import glob
import pytrec_eval
import os
import traceback

# Vérifier que les chemins sont définis
try:
    QRELS_DIR
    RUN_DIR
    EVAL_DIR
except NameError:
    print("ERREUR: Variables de chemin non définies. Exécutez la cellule de configuration complète.")
    raise

print(f"Préparation des Qrels depuis: {QRELS_DIR}")
qrels_files = sorted(glob.glob(os.path.join(QRELS_DIR, "qrels.*.txt")))
if not qrels_files: print(f"ATTENTION: Aucun fichier Qrels trouvé dans {QRELS_DIR}."); qrels_dict = {}
else:
    print(f"Fichiers Qrels trouvés: {qrels_files}")
    all_qrels_data = []
    for qf in qrels_files:
        try:
            qrels_df = pd.read_csv(qf, sep='\s+', names=['query_id', 'unused', 'doc_id', 'relevance'], dtype={'query_id': str, 'unused': str, 'doc_id': str, 'relevance': int})
            all_qrels_data.append(qrels_df[['query_id', 'doc_id', 'relevance']])
        except Exception as e: print(f"Erreur lecture Qrels {qf}: {e}")
    if not all_qrels_data: print("ERREUR: Impossible lire données Qrels."); qrels_dict = {}
    else:
        combined_qrels_df = pd.concat(all_qrels_data, ignore_index=True)
        qrels_dict = {}
        for _, row in combined_qrels_df.iterrows():
            qid, did, rel = row['query_id'], row['doc_id'], int(row['relevance'])
            if rel &lt; 0: continue
            if qid not in qrels_dict: qrels_dict[qid] = {}
            qrels_dict[qid][did] = rel
        print(f"Total {len(qrels_dict)} requêtes avec jugements chargées.")

# --- Évaluation des Runs ---
if not qrels_dict: print("\nAucun jugement de pertinence chargé, impossible d'évaluer.")
else:
    measures = {'map', 'P_10'}
    evaluator = pytrec_eval.RelevanceEvaluator(qrels_dict, measures)
    run_files = sorted(glob.glob(os.path.join(RUN_DIR, "*.txt"))) # Prend tous les .txt dans RUN_DIR
    print(f"\n{len(run_files)} fichiers de run à évaluer trouvés dans {RUN_DIR}.")

    results_summary = []
    if not run_files: print(f"ATTENTION: Aucun fichier de run (.txt) trouvé dans {RUN_DIR}.")
    else:
        for run_file in run_files:
            run_name = os.path.basename(run_file)
            print(f"\n--- Évaluation: {run_name} ---")
            run_dict = {}
            error_count = 0
            try:
                with open(run_file, 'r', encoding='utf-8') as f_run:
                    for line in f_run:
                        parts = line.strip().split();
                        if len(parts) != 6: error_count += 1; continue
                        qid, _, did, _, score, _ = parts
                        try: score = float(score)
                        except ValueError: error_count += 1; continue
                        if qid not in run_dict: run_dict[qid] = {}
                        run_dict[qid][did] = score
                if error_count &gt; 0: print(f"  Avertissement: {error_count} lignes mal formatées ignorées.")

                filtered_run_dict = {qid: docs for qid, docs in run_dict.items() if qid in qrels_dict}
                ignored_q = len(run_dict) - len(filtered_run_dict)
                if ignored_q &gt; 0: print(f"  Avertissement: {ignored_q} requêtes run ignorées (absentes Qrels).")
                if not filtered_run_dict: print("  Erreur: Aucune requête ne correspond aux Qrels."); continue

                eval_results = evaluator.evaluate(filtered_run_dict)
                all_maps = [q_res.get("map", 0) for q_res in eval_results.values()]
                all_p10s = [q_res.get("P_10", 0) for q_res in eval_results.values()]
                avg_map = sum(all_maps) / len(all_maps) if all_maps else 0
                avg_p10 = sum(all_p10s) / len(all_p10s) if all_p10s else 0

                print(f"  MAP: {avg_map:.4f}")
                print(f"  P@10: {avg_p10:.4f}")

                # Extraire infos pour résumé
                parts = run_name.replace('.txt','').split('_')
                if len(parts) &gt;= 3:
                    index_type, query_type, model_type = parts[0], parts[1], parts[2]
                    if len(parts) &gt; 3 and parts[3] == 'rm3': model_type += "+RM3" # Gérer RM3
                    results_summary.append({
                        "Run Name": run_name, "Index": index_type,
                        "Query Type": query_type.capitalize(),
                        "Weighting Scheme": model_type.upper(),
                        "MAP": avg_map, "P@10": avg_p10
                    })
                else: print(f"  Avertissement: Impossible parser nom run '{run_name}'.")

            except FileNotFoundError: print(f"  Erreur: Fichier run non trouvé: {run_file}")
            except Exception as e: print(f"  Erreur évaluation {run_name}: {e}"); traceback.print_exc()

        # Afficher et sauvegarder résumé
        if results_summary:
            print("\n\n=== Tableau Récapitulatif des Résultats ===")
            results_df = pd.DataFrame(results_summary)
            results_df = results_df.sort_values(by=["Index", "Query Type", "Weighting Scheme"]) # Trier

            try: # Afficher Tableaux Pivots
                pivot_map = results_df.pivot_table(index=['Query Type', 'Weighting Scheme'], columns='Index', values='MAP')
                print("\n--- MAP ---"); print(pivot_map.to_markdown(floatfmt=".4f"))
                pivot_p10 = results_df.pivot_table(index=['Query Type', 'Weighting Scheme'], columns='Index', values='P@10')
                print("\n--- P@10 ---"); print(pivot_p10.to_markdown(floatfmt=".4f"))
            except Exception as e_pivot: print(f"\nErreur création tableaux pivots: {e_pivot}")

            # Sauvegarder le DataFrame complet
            summary_file_path = os.path.join(EVAL_DIR, "evaluation_summary_final.csv") # Nom final
            try:
                 results_df.to_csv(summary_file_path, index=False)
                 print(f"\nTableau récapitulatif complet sauvegardé: {summary_file_path}")
            except Exception as e_save: print(f"\nErreur sauvegarde résumé: {e_save}")
        else: print("\nAucun résultat d'évaluation à afficher.")


# --- Nouvelle Cellule ---

# === Cellule 7: Exécuter la Recherche Améliorée (RM3) ===
# Applique RM3 sur la meilleure configuration de base identifiée à l'étape 6.
# !! N'OUBLIEZ PAS DE CONFIGURER LES VARIABLES BEST_... CI-DESSOUS !!

from pyserini.search.lucene import LuceneSearcher
from jnius import autoclass, JavaException
from tqdm.notebook import tqdm
import time
import traceback
import os

# Recharger ClassicSimilarity au cas où
try: ClassicSimilarity = autoclass('org.apache.lucene.search.similarities.ClassicSimilarity')
except Exception: ClassicSimilarity = None

# Vérifier variables nécessaires
try:
    INDEX_DIR_BASELINE; INDEX_DIR_PREPROC; RUN_DIR; K_RESULTS; EVAL_DIR;
    queries_short; queries_long; queries_short_preprocessed; queries_long_preprocessed;
    preprocess_text;
except NameError as e: print(f"ERREUR: Variable {e} manquante. Exécutez config complète."); raise

# --- À CONFIGURER selon vos meilleurs résultats de l'Étape 6 ---
# !! MODIFIEZ CECI EN FONCTION DE VOS RÉSULTATS D'ÉVALUATION !!
print("--- Configuration RM3 ---")
print("Veuillez éditer les variables BEST_... ci-dessous en fonction de vos meilleurs résultats MAP de l'étape précédente.")
# Exemple: si preproc + long + bm25 était le meilleur
BEST_INDEX_PATH = INDEX_DIR_PREPROC           # Ex: INDEX_DIR_BASELINE ou INDEX_DIR_PREPROC
BEST_QUERIES = queries_long_preprocessed      # Ex: queries_short, queries_long, ..._preprocessed
BEST_MODEL_BASE = 'bm25'                      # Ex: 'bm25' ou 'tfidf'
BEST_RUN_TAG_PREFIX = "preproc_long"          # Ex: 'baseline_short', 'preproc_long'
USE_PREPROC_QUERY_FOR_RM3 = False             # Généralement False si BEST_QUERIES est déjà prétraité
# ----------------------------------------------------------------
print(f"Configuration choisie pour RM3:")
print(f"  Index: {os.path.basename(BEST_INDEX_PATH)}")
# print(f"  Requêtes: (variable BEST_QUERIES)") # Difficile d'afficher le nom de la variable
print(f"  Modèle Base: {BEST_MODEL_BASE}")
print(f"  Préfixe Tag: {BEST_RUN_TAG_PREFIX}")
print(f"  Utiliser Preproc Requête?: {USE_PREPROC_QUERY_FOR_RM3}")

# Nom du fichier et tag pour le run RM3
PRF_RUN_FILE = os.path.join(RUN_DIR, f"{BEST_RUN_TAG_PREFIX}_{BEST_MODEL_BASE}_rm3.txt")
RM3_RUN_TAG = f"{BEST_RUN_TAG_PREFIX}_{BEST_MODEL_BASE}_rm3"

# Paramètres RM3
rm3_config = {'fb_terms': 10, 'fb_docs': 10, 'original_query_weight': 0.5}
print(f"  Paramètres RM3: {rm3_config}")

# --- Fonction de recherche RM3 (séquentielle) ---
# (Définition identique à celle de search_code_final, on peut la réutiliser si elle est dans la portée)
# Par sécurité, on la redéfinit ici au cas où l'utilisateur n'exécute que cette cellule après setup.
def perform_search_sequential_rm3(queries, index_path, model_base, k, output_run_file, run_tag, use_preprocessed_query=False, rm3_params=None):
    start_time = time.time()
    print(f"\nDébut recherche SÉQUENTIELLE RM3: Modèle='{model_base}+RM3', Tag='{run_tag}', k={k}")
    all_results_list = []
    searcher = None
    try:
        print(f"  Initialisation LuceneSearcher..."); searcher = LuceneSearcher(index_path); print(f"  LuceneSearcher initialisé.")
        if model_base == 'bm25': print("  Config BM25 (base)..."); searcher.set_bm25(k1=0.9, b=0.4)
        elif model_base == 'tfidf':
            if ClassicSimilarity is None: raise ValueError("ClassicSimilarity non chargée.")
            print("  Config ClassicSimilarity (base)...")
            try: searcher.set_similarity(ClassicSimilarity())
            except Exception as e_sim: print(f"ERREUR config ClassicSimilarity: {e_sim}"); return
        else: print(f"Modèle base '{model_base}' non reconnu, utilise BM25."); searcher.set_bm25()
        print("  Activation RM3..."); searcher.set_rm3(**rm3_params); print("  RM3 activé.")
        query_errors = 0
        for query_id, query_text in tqdm(queries.items(), desc=f"Recherche {run_tag}"):
            try:
                if 'preprocess_text' not in globals(): raise NameError("preprocess_text non définie.")
                search_text = preprocess_text(query_text) if use_preprocessed_query else query_text
                if not search_text.strip(): continue
                hits = searcher.search(search_text, k=k)
                for i in range(len(hits)):
                    rank, doc_id, score = i + 1, hits[i].docid, hits[i].score
                    if doc_id is None: continue
                    all_results_list.append(f"{query_id} Q0 {doc_id} {rank} {score:.6f} {run_tag}\n")
            except Exception as e_query:
                query_errors += 1
                if query_errors &lt; 5: print(f"\nErreur recherche RM3 QID {query_id}: {e_query}")
                elif query_errors == 5: print("\nPlusieurs erreurs recherche RM3...")
        if all_results_list:
             with open(output_run_file, 'w', encoding='utf-8') as f_out: f_out.writelines(all_results_list)
             print(f"\n  {len(all_results_list)} lignes résultats écrites.")
        else: print("\n  Avertissement: Aucun résultat RM3 généré.")
        if query_errors &gt; 0: print(f"  Avertissement: {query_errors} erreurs sur requêtes.")
        end_time = time.time()
        print(f"Recherche RM3 terminée pour {run_tag}. Sauvegardé dans {output_run_file}")
        print(f"Temps écoulé: {end_time - start_time:.2f} secondes.")
    except Exception as e_main: print(f"\nERREUR MAJEURE run RM3 {run_tag}: {e_main}"); traceback.print_exc()
    finally:
        if searcher: print(f"  Nettoyage implicite ressources {run_tag}.")

# Lancer la recherche RM3 (après configuration des variables BEST_...)
print("\nLancement de la recherche RM3...")
perform_search_sequential_rm3(
    BEST_QUERIES, BEST_INDEX_PATH, BEST_MODEL_BASE, K_RESULTS,
    PRF_RUN_FILE, RM3_RUN_TAG,
    use_preprocessed_query=USE_PREPROC_QUERY_FOR_RM3, rm3_params=rm3_config
)

print("\n--- Exécution de la recherche RM3 terminée. ---")


# --- Nouvelle Cellule ---

</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>(code propre)_RI_tp1_6avril25.ipynb</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour 1mars2018.R -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">1mars2018.R</h2>
                    <p class="text-gray-300 mt-1">Ce code R charge, explore et nettoie des données de type recensement, puis construit et évalue des modèles de prédiction (arbre de décision et réseau neuronal) pour classer les groupes de revenus.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: données, nettoyage, modélisation, prédiction, R</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-plaintext">#Technology: I used R for the analysis (here is the code) 

##Auteur: Dominique Loyer


#Question 1 and 2 and exploration of data

Census &lt;- read.csv("~/Desktop/CensusClean.csv")
View(Census)
summary(Census)
attach(Census)
str(Census)
head(Census)
tail(Census)
getwd()
pwc &lt;- readxl::read_excel("Census.xlsx")
pwc &lt;- read("Census.xlsx")
view(pwc)
pwc
View(pwc)
str(pwc)
head(pwc)
subset (pwc, Education %in% "Masters")
subset (pwc, Education %in% "Masters" AND `Income Group` %in% "50k" OR `Income Group` %in% "50k.")
subset (pwc, Education %in% "Masters" AND Income Group %in% "50k" OR Income Group %in% "50k.")
subset (pwc, Education %in% "Masters" OR "Doctorates")
subset (pwc, Education %in% "Masters" | "Doctorates")
subset (pwc, Education %in% "Masters"|"Doctorates")
subset (pwc, Education %in% "Masters")
master &lt;- subset (pwc, Education %in% "Masters")
filter(master)
master50kplus &lt;- subset (pwc, `Income Group` %in% "50k")
master50kplus
master50kplusDot &lt;- subset (master50kplus, `Income Group` %in% "50k.")
master50kplusDot
master
master50kplus &lt;- subset (master, `Income Group` %in% "50k")
master50kplus
master50kplus &lt;- subset (master, `Income Group` %in% "&gt;50k")
master50kplus
master50kplus &lt;- subset (master, `Income Group` %in% &gt;50k)
master50kplus &lt;- subset (master, `Income Group` &gt;50k)
master50kplus &lt;- subset (master, `Income Group` &gt;50k)
master
master$`Income Group`
master50kplus &lt;- subset (master, `Income Group` %in% "&gt;50K")
master50kplus
master50kplusDot &lt;- subset (master50kplus, `Income Group` %in% "&gt;50K.")
master50kplusDot
master50kplus
master50kplusDot &lt;- subset (master, `Income Group` %in% "&gt;50K.")
master50kplus+master50kplusDot
master50kplusDot
dim(master50kplus)
dim(master50kplusDot)
426+500
totalMaster50kplus &lt;- 500+426
totalMaster50kplus
doctorate &lt;- subset (pwc, Education %in% "Doctorate")
doctorate
doctorate50kplus &lt;- subset (doctorate, `Income Group` %in% "&gt;50K")
doctorate50kplus
doctorate50kplusDot &lt;- subset (doctorate, `Income Group` %in% "&gt;50K.")
doctorate50kplusDot
dim(doctorate50kplus)
dim(doctorate50kplusDot)
totalDoctorate50plus &lt;- 130+125
totalDoctorate50plus
totalDoctorate50plus+totalMaster50kplus
TotalDocPlusMasterEarn50kplus &lt;- totalDoctorate50plus+totalMaster50kplus
TotalDocPlusMasterEarn50kplus / 30511
people50less &lt;- subset (pwc, `Income Group` %in% "&lt;=50K")
people50less
people50lessDot &lt;- subset (pwc, `Income Group` %in% "&lt;=50K.")
people50lessDot
dim(people50less)
dim(people50lessDot)
peopleLess50K &lt;- 10835+12430
peopleLess50K
plot(peopleLess50K)
hist(peopleLess50K)


#Question 3

##Cleaningmytreeadult

###categorical variables as factor
pwcClean$workclass &lt;- as.factor(pwcClean$workclass)
pwcClean$`Income Group` &lt;- as.factor(pwcClean$`Income Group`)
pwcClean$Education &lt;- as.factor(pwcClean$Education)
pwcClean$`Occupation Status` &lt;- as.factor(pwcClean$`Occupation Status`)
pwcClean$Relationship &lt;- as.factor(pwcClean$Relationship)
pwcClean$Gender &lt;- as.factor(pwcClean$Gender)
pwcClean$`Native country` &lt;- as.factor(pwcClean$`Native country`)
summary(pwcClean)
pwcClean$`Marital Status` &lt;- as.factor(pwcClean$`Marital Status`)
summary(pwcClean)
pwcClean$Age=(pwcClean$Age-min(pwcClean$Age))/(max(pwcClean$Age)-min(pwcClean$Age))

range(pwcClean$`Demographic Adjustment`)
hist(pwcClean$`Demographic Adjustment`)

###replacing missing values and merging Income Group (50k and 50k.)

install.packages("tidyr")
library("tidyr")
pwc$`Occupation Status` &lt;- sub("?", "Other-service", pwc$`Occupation Status`)
subset (pwc, Education %in% "Masters" AND `Income Group` %in% "50k" OR `Income Group` %in% "50k.")
pwc$workclass[pwc$workclass==" ?"] = as.character(sample(pwc$workclass[which(pwc$workclass !=" ?")], 1774, replace = FALSE))
people50lessDot &lt;- subset (pwc, `Income Group` %in% "&lt;=50K.")
people50less &lt;- subset (pwc, `Income Group` %in% "&lt;=50K")



###normalization with Min-Max
pwcClean$`Demographic Adjustment`=(pwcClean$`Demographic Adjustment`-min(pwcClean$`Demographic Adjustment`))/(max(pwcClean$`Demographic Adjustment`)-min(pwcClean$`Demographic Adjustment`))
hist(pwcClean$`Demographic Adjustment`)
pwcClean$`Years of Education`=(pwcClean$`Years of Education`-min(pwcClean$`Years of Education`))/(max(pwcClean$`Years of Education`)-min(pwcClean$`Years of Education))
pwcClean$`Years of Education`=(pwcClean$`Years of Education`-min(pwcClean$`Years of Education`))/(max(pwcClean$`Years of Education`)-min(pwcClean$`Years of Education))
pwcClean$`Years of Education`=(pwcClean$`Years of Education`-min(pwcClean$`Years of Education`))/(max(pwcClean$`Years of Education`)-min(pwcClean$`Years of Education`))
pwcClean$`capital-gain`=(pwcClean$`capital-gain`-min(pwcClean$`capital-gain`))/(max(pwcClean$`capital-gain`)-min(pwcClean$`capital-gain`))
pwcClean$`capital-loss`=(pwcClean$`capital-loss`-min(pwcClean$`capital-loss`))/(max(pwcClean$`capital-loss`)-min(pwcClean$`capital-loss`))
pwcClean$`hours-per-week`=(pwcClean$`hours-per-week`-min(pwcClean$`hours-per-week`))/(max(pwcClean$`hours-per-week`)-min(pwcClean$`hours-per-week`))

###Normalized and cleaned data
pwcClean.normalized &lt;- pwcClean
pwcClean.normalizedCopy &lt;- pwcClean.normalized



#Decision Tree
##pruning the tree with rpart
install.packages("rpart")
library(rpart)
library(rpart.plot)
mytreeadult=rpart(`Income Group`~Education+workclass+`Occupation Status`+Gender+Age+`hours-per-week`
                  , data=pwcClean.normalized, method="class", control=rpart.control(minsplit=1))
mytreeadult
plot(mytreeadult)
rpart.plot(mytreeadult, type=3, extra=101, fallen.leaves = TRUE)
text(mytreeadult, use.n=T, all=T, pretty=0, cex=0.9, xpd=TRUE)
estincome.class=predict(mytreeadult, data=pwcClean.normalized, type="class")

##cross-validation table

t1=table(`Income Group`, estincome.class)
t1
(10061+1354)+(11564+1505)/30511
(10061+1354+11564+1505)/30511



###Training data 20000 out of 30511
index &lt;- sample(1:nrow(pwcClean.normalized), 20000)
pwc.test = pwcClean.normalized[index,]
pwc.valid = pwcClean.normalized[-index,]

###validation data
Tpwc=table(pwc.valid$`Income Group`,pwc.valid$est.income)
Tpwc
(7457+1519)/(30511-20000)

#Neural network with 10 hidden layers

require(nnet)
library(nnet)
set.seed(99999999)

pwc.net = nnet(`Income Group`~.,data=pwc.test,size=10)
pwc.valid$est.income = predict(pwc.net,pwc.valid,type="class")
Tpwc=table(pwc.valid$`Income Group`,pwc.valid$est.income)
Tpwc


clear(
  
)
rpart(formula, data=, method=,control=)
###
rpart(formula, data=, method=,control=)
fit&lt;-rpart(Default_On_Payment~Status_Checking_Acc+Duration_in_Months+Credit_History+Purposre_Credit_Taken+
              Credit_Amount+Savings_Acc+Years_At_Present_Employment+Inst_Rt_Income+Marital_Status_Gender+
              Other_Debtors_Guarantors+Current_Address_Yrs+Property+Age+Other_Inst_Plans+Housing+
              Num_CC+Job+Dependents+Telephone+Foreign_Worker,
             data=cust_data, method="class",
           control=rpart.control(minsplit=20, cp=0.01))











</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>1mars2018.R</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour ARIMA.R -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">ARIMA.R</h2>
                    <p class="text-gray-300 mt-1">Ce code R importe des données de ventes, les transforme en série chronologique, les décompose en composantes saisonnière, de tendance et de résidus, puis ajuste un modèle ARIMA automatique pour générer et visualiser des prévisions.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: Séries chronologiques, Prévision, ARIMA, Décomposition, Analyse</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-plaintext">#Setting working directory
setwd("C:/Users/rpand/Desktop/Documents/Classes/Classes/Time_Series_Accelerator")

library("forecast")

#Reading the data
sales &lt;- read.csv("sales.csv")

#What kind of data we have
sales
head(sales)
tail(sales)

#Create time series from the input data, [,1] is for first column and all rows. freq = 12, is for 12 months. For quarters it will be freq = 4
sales &lt;- ts(sales[,1],start=1995,freq=12)

write.csv(sales,"newsales.csv")

#Let's view, what is the output
sales

#Plot Time Series
plot(sales)

#Divides into Seasonal, Trend and Remainder. S.Window controls how rapidly the seasonal component can change

apts &lt;- decompose(sales)

plot (apts)

# Select Best Model

arima_model &lt;- auto.arima(sales)

arima_model

error_estimate_ARIMA &lt;- accuracy(arima_model)

forecast(arima_model, 20)

plot(forecast(arima_model,20))

# ME: Mean Error
# RMSE: Root Mean Squared Error
# MAE: Mean Absolute Error
# MPE: Mean Percentage Error
# MAPE: Mean Absolute Percentage Error
# MASE: Mean Absolute Scaled Error
# ACF1: Autocorrelation of errors at lag 1.


</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>ARIMA.R</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour backend_7juin25.html -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">backend_7juin25.html</h2>
                    <p class="text-gray-300 mt-1">Une interface web interactive qui permet aux utilisateurs de soumettre une URL ou du texte pour que son niveau de crédibilité soit analysé par un service backend et affiché via une jauge et des détails.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: crédibilité, information, évaluation, interface web, frontend</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-xml">&lt;!DOCTYPE html&gt;
&lt;html lang="fr"&gt;
&lt;head&gt;
    &lt;meta charset="UTF-8"&gt;
    &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt;
    &lt;title&gt;Évaluation de Crédibilité&lt;/title&gt;
    &lt;script src="https://cdn.tailwindcss.com"&gt;&lt;/script&gt;
    &lt;!-- Le script pour les icônes sera déplacé à la fin du body pour un chargement optimal --&gt;
    &lt;style&gt;
        /* Style personnalisé pour la jauge */
        .gauge-container {
            width: 200px;
            height: 100px;
            position: relative;
            overflow: hidden;
            border-radius: 100px 100px 0 0;
        }
        .gauge-background {
            width: 100%;
            height: 100%;
            background: linear-gradient(to right, #ef4444, #eab308, #22c55e); /* Red-Yellow-Green */
            position: absolute;
            top: 0;
            left: 0;
        }
        .gauge-mask {
            width: 100%;
            height: 100%;
            background-color: #f3f4f6; /* bg-gray-100 */
            position: absolute;
            top: 0;
            left: 0;
            transform-origin: bottom center;
            /* La rotation sera ajustée par JS */
            transition: transform 0.5s ease-in-out;
        }
        .gauge-center {
            width: 160px;
            height: 80px;
            background-color: #f3f4f6; /* bg-gray-100 */
            position: absolute;
            bottom: 0;
            left: 20px;
            border-radius: 80px 80px 0 0;
            display: flex;
            flex-direction: column;
            justify-content: flex-end;
            align-items: center;
            padding-bottom: 5px;
        }
        .gauge-score {
            font-size: 1.5rem; /* text-2xl */
            font-weight: bold;
        }
        .gauge-label {
            font-size: 0.75rem; /* text-xs */
            color: #6b7280; /* text-gray-500 */
        }
        /* Style pour surligner les mots (explication LIME) */
        .highlight-positive { background-color: rgba(34, 197, 94, 0.3); padding: 0 2px; border-radius: 3px; }
        .highlight-negative { background-color: rgba(239, 68, 68, 0.3); padding: 0 2px; border-radius: 3px; }

        /* Style pour les barres simples */
        .bar-container {
            height: 10px;
            background-color: #e5e7eb; /* bg-gray-200 */
            border-radius: 5px;
            overflow: hidden;
            width: 100px; /* Ajuster si nécessaire */
        }
        .bar {
            height: 100%;
            border-radius: 5px;
            transition: width 0.5s ease-in-out;
        }
    &lt;/style&gt;
&lt;/head&gt;
&lt;body class="bg-gray-100 font-sans p-4 md:p-8"&gt;

    &lt;div class="container mx-auto max-w-3xl bg-white shadow-lg rounded-lg p-6 md:p-8"&gt;

        &lt;h1 class="text-2xl md:text-3xl font-bold text-center text-gray-800 mb-6"&gt;
            Système d'Évaluation de la Crédibilité de l'Information
        &lt;/h1&gt;

        &lt;div class="mb-6"&gt;
            &lt;label for="inputData" class="block text-sm font-medium text-gray-700 mb-2"&gt;
                Entrez une URL ou collez du texte :
            &lt;/label&gt;
            &lt;textarea id="inputData" rows="4" class="w-full p-3 border border-gray-300 rounded-md focus:ring-2 focus:ring-indigo-500 focus:border-indigo-500 transition duration-150 ease-in-out" placeholder="Ex: https://www.example.com ou 'Ce texte semble suspect...'"&gt;&lt;/textarea&gt;
            &lt;button id="verifyButton" class="mt-3 w-full inline-flex justify-center items-center px-6 py-3 border border-transparent text-base font-medium rounded-md shadow-sm text-white bg-indigo-600 hover:bg-indigo-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-indigo-500 transition duration-150 ease-in-out disabled:opacity-50"&gt;
                &lt;i data-lucide="search" class="mr-2 h-5 w-5"&gt;&lt;/i&gt; Vérifier la Crédibilité
            &lt;/button&gt;
        &lt;/div&gt;

        &lt;div id="reportSection" class="hidden mt-8 border-t border-gray-200 pt-6"&gt;
            &lt;h2 class="text-xl md:text-2xl font-semibold text-gray-800 mb-4 text-center"&gt;Rapport d'Analyse&lt;/h2&gt;

            &lt;div class="flex flex-col items-center mb-6 p-4 bg-gray-50 rounded-lg"&gt;
                &lt;h3 class="text-lg font-medium text-gray-700 mb-2"&gt;Score de Crédibilité Global&lt;/h3&gt;
                &lt;div class="gauge-container mb-2"&gt;
                    &lt;div class="gauge-background"&gt;&lt;/div&gt;
                    &lt;div id="gaugeMask" class="gauge-mask"&gt;&lt;/div&gt;
                    &lt;div class="gauge-center"&gt;
                        &lt;span id="gaugeScore" class="gauge-score"&gt;--&lt;/span&gt;
                        &lt;span class="gauge-label"&gt;0 = Faible, 10 = Élevé&lt;/span&gt;
                    &lt;/div&gt;
                &lt;/div&gt;
                &lt;p id="reportSummary" class="text-center text-gray-600 text-sm italic"&gt;&lt;/p&gt;
            &lt;/div&gt;
             
             &lt;!-- Section des constats (findings) --&gt;
            &lt;div id="findingsSection" class="bg-gray-50 p-4 rounded-lg shadow-sm"&gt;
                 &lt;h4 class="font-semibold text-gray-700 mb-3 border-b pb-2 flex items-center"&gt;
                    &lt;i data-lucide="list-checks" class="mr-2 h-5 w-5 text-indigo-600"&gt;&lt;/i&gt; Détails de l'Évaluation
                 &lt;/h4&gt;
                 &lt;div id="findingsList" class="space-y-2"&gt;
                     &lt;!-- Les constats (findings) du backend seront insérés ici --&gt;
                 &lt;/div&gt;
            &lt;/div&gt;

        &lt;/div&gt; 
        
        &lt;div id="loadingIndicator" class="hidden text-center mt-6"&gt;
             &lt;div class="inline-flex items-center px-4 py-2 font-semibold leading-6 text-sm shadow rounded-md text-indigo-700 bg-white transition ease-in-out duration-150 cursor-not-allowed"&gt;
                 &lt;svg class="animate-spin -ml-1 mr-3 h-5 w-5 text-indigo-500" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"&gt;
                     &lt;circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"&gt;&lt;/circle&gt;
                     &lt;path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"&gt;&lt;/path&gt;
                 &lt;/svg&gt;
                 Analyse en cours...
            &lt;/div&gt;
        &lt;/div&gt;

        &lt;div id="errorSection" class="hidden mt-6 p-4 bg-red-100 border border-red-400 text-red-700 rounded-lg"&gt;
             &lt;h4 class="font-bold flex items-center"&gt;&lt;i data-lucide="alert-triangle" class="mr-2 h-5 w-5"&gt;&lt;/i&gt; Erreur&lt;/h4&gt;
             &lt;p id="errorMessage" class="text-sm"&gt;&lt;/p&gt;
        &lt;/div&gt;

    &lt;/div&gt;

    &lt;!-- ===== CORRECTION : Scripts déplacés à la fin du body ===== --&gt;
    &lt;script src="https://cdn.jsdelivr.net/npm/lucide-static@latest/dist/lucide.min.js"&gt;&lt;/script&gt;
    &lt;script&gt;
        // On attend que le DOM soit entièrement chargé avant d'exécuter le script.
        document.addEventListener('DOMContentLoaded', function () {
            // --- Éléments DOM ---
            const inputDataEl = document.getElementById('inputData');
            const verifyButton = document.getElementById('verifyButton');
            const reportSection = document.getElementById('reportSection');
            const errorSection = document.getElementById('errorSection');
            const errorMessageEl = document.getElementById('errorMessage');
            const loadingIndicator = document.getElementById('loadingIndicator');

            // Éléments du rapport
            const gaugeScoreEl = document.getElementById('gaugeScore');
            const gaugeMaskEl = document.getElementById('gaugeMask');
            const reportSummaryEl = document.getElementById('reportSummary');
            const findingsListEl = document.getElementById('findingsList');


            // Initialiser Lucide Icons
            lucide.createIcons();

            // --- Logique ---

            verifyButton.addEventListener('click', handleVerificationRequest);

            async function handleVerificationRequest() {
                const inputText = inputDataEl.value.trim();
                if (!inputText) {
                    showError("Veuillez entrer une URL ou du texte.");
                    return;
                }

                // Afficher le chargement, masquer l'ancien rapport/erreur
                loadingIndicator.classList.remove('hidden');
                reportSection.classList.add('hidden');
                errorSection.classList.add('hidden');
                verifyButton.disabled = true;

                try {
                    // =================================================================
                    // === MODIFICATION CLÉ : APPEL RÉEL AU SERVEUR (BACKEND) ===
                    // =================================================================
                    
                    // METTEZ VOTRE URL NGROK ICI !
                    const apiUrl = 'https://37e9-34-136-178-210.ngrok-free.app/api/verify'; // &lt;--- REMPLACEZ PAR VOTRE URL NGROK

                    const response = await fetch(apiUrl, {
                        method: 'POST',
                        headers: { 'Content-Type': 'application/json' },
                        body: JSON.stringify({ input_data: inputText })
                    });

                    if (!response.ok) {
                        const errorData = await response.json();
                        throw new Error(errorData.error || `Erreur serveur: ${response.status}`);
                    }
                    const reportData = await response.json();
                    
                    // Afficher le rapport
                    displayReport(reportData);
                    reportSection.classList.remove('hidden');

                } catch (error) {
                    console.error("Erreur lors de la vérification:", error);
                    showError(error.message || "Une erreur inconnue est survenue. Vérifiez l'URL du serveur et que celui-ci est bien en cours d'exécution.");
                } finally {
                    // Masquer le chargement, réactiver le bouton
                    loadingIndicator.classList.add('hidden');
                    verifyButton.disabled = false;
                }
            }

            function displayReport(report) {
                // 1. Score Global et Résumé
                const score = report.final_score; // Le score est maintenant sur 10
                gaugeScoreEl.textContent = score.toFixed(1);
                // Calculer l'angle pour le masque de la jauge (0 score = 0 deg, 10 score = 180 deg)
                const rotation = Math.max(0, Math.min(180, (10 - score) / 10 * 180));
                gaugeMaskEl.style.transform = `rotate(${rotation}deg)`;
                reportSummaryEl.textContent = report.summary || "Résumé non disponible.";
                
                // 2. Afficher les constats (findings)
                findingsListEl.innerHTML = ''; // Vider la liste précédente
                if (report.findings &amp;&amp; report.findings.length &gt; 0) {
                    report.findings.forEach(finding =&gt; {
                        const impactColor = finding.impact &gt;= 0 ? 'text-green-600' : 'text-red-600';
                        const bgColor = finding.impact &gt;= 0 ? 'bg-green-50' : 'bg-red-50';
                        const icon = finding.impact &gt;= 0 
                            ? `&lt;i data-lucide="arrow-up-circle" class="h-5 w-5 text-green-500"&gt;&lt;/i&gt;`
                            : `&lt;i data-lucide="arrow-down-circle" class="h-5 w-5 text-red-500"&gt;&lt;/i&gt;`;

                        const findingElement = document.createElement('div');
                        findingElement.className = `p-2 ${bgColor} rounded-md flex items-start space-x-3`;
                        findingElement.innerHTML = `
                            &lt;div class="flex-shrink-0 pt-0.5"&gt;${icon}&lt;/div&gt;
                            &lt;div class="flex-1"&gt;
                                &lt;p class="text-sm font-semibold text-gray-800"&gt;${finding.source}&lt;/p&gt;
                                &lt;p class="text-sm text-gray-600"&gt;${finding.description}&lt;/p&gt;
                                ${finding.evidence ? `&lt;p class="text-xs text-gray-500 mt-1"&gt;&lt;em&gt;Évidence: ${finding.evidence}&lt;/em&gt;&lt;/p&gt;` : ''}
                            &lt;/div&gt;
                            &lt;div class="font-semibold text-sm ${impactColor}"&gt;
                                ${finding.impact &gt; 0 ? '+' : ''}${(finding.impact * 5).toFixed(1)}
                            &lt;/div&gt;
                        `;
                        findingsListEl.appendChild(findingElement);
                    });
                } else {
                    findingsListEl.innerHTML = `&lt;p class="text-sm text-gray-500 text-center"&gt;Aucun détail spécifique n'a été généré pour cette analyse.&lt;/p&gt;`;
                }
                lucide.createIcons(); // Recréer les icônes ajoutées dynamiquement
            }

            // --- Gestion des erreurs ---
            function showError(message) {
                errorMessageEl.textContent = message;
                errorSection.classList.remove('hidden');
                reportSection.classList.add('hidden'); // Masquer le rapport si erreur
            }
        });
    &lt;/script&gt;
&lt;/body&gt;
&lt;/html&gt;
</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>backend_7juin25.html</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour Cart_ClassificationTree_V1.R -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">Cart_ClassificationTree_V1.R</h2>
                    <p class="text-gray-300 mt-1">Ce code R construit, élague et visualise un arbre de décision de classification pour prédire le défaut de paiement des clients à partir de données financières.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: arbre de décision, classification, défaut de paiement, r, rpart</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-plaintext">###
setwd("C:/Users/rpand/Desktop/Documents/Classes/Classes/Decision_Tree_Accelerator")
library(rpart)
##Read the data in the file
cust_data&lt;-read.csv("Default_On_Payment_CHAID.csv")

###rpart(formula, data=, method=,control=) 
# fit&lt;-rpart(Default_On_Payment~Status_Checking_Acc+Duration_in_Months+Credit_History+Purposre_Credit_Taken+
#              Credit_Amount+Savings_Acc+Years_At_Present_Employment+Inst_Rt_Income+Marital_Status_Gender+
#              Other_Debtors_Guarantors+Current_Address_Yrs+Property+Age+Other_Inst_Plans+Housing+
#              Num_CC+Job+Dependents+Telephone+Foreign_Worker,
#             data=cust_data, method="class", 
#            control=rpart.control(minsplit=20, cp=0.01))


fit&lt;-rpart(Default_On_Payment~Status_Checking_Acc+Credit_History, data=cust_data, method="class", 
           control=rpart.control(minsplit=50, cp=0.001))


##display complexity parameter table
printcp(fit)

###plot cross-validation results
plotcp(fit)

###detailed results including splits
summary(fit)
printcp(fit)

###Prune the tree to the desired size ..at min error cp
pfit&lt;- prune(fit, cp = 0.001)

###plot decision tree 
plot(pfit, uniform=TRUE, main="Classification Tree for Default_on_payment")

###label the decision tree plot 
text(pfit,splits = TRUE, use.n=TRUE, all=TRUE, cex=0.5, pretty=1)
labels(pfit)
library(rpart.plot)

prp(pfit, type=4, extra=4, under=TRUE)


</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>Cart_ClassificationTree_V1.R</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour check_env.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">check_env.py</h2>
                    <p class="text-gray-300 mt-1">Ce script Python affiche des informations diagnostiques sur l'environnement d'exécution, notamment le chemin de l'exécutable Python et les chemins de recherche des modules.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: Python, environnement, diagnostic, chemins, modules</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python"># check_env.py
import sys
import os

print("--- DIAGNOSTIC DE L'ENVIRONNEMENT PYTHON ---")
print(f"Chemin de l'exécutable Python (sys.executable) : {sys.executable}")
print("\nChemins où Python cherche les paquets (sys.path):")
for path in sys.path:
    print(f"- {path}")
print("\n--- FIN DU DIAGNOSTIC ---")
</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>check_env.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour chercheur110725.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">chercheur110725.py</h2>
                    <p class="text-gray-300 mt-1">Une application Tkinter interactive qui teste l'ajout séquentiel de composants d'interface utilisateur, comme une barre de recherche et un tableau de résultats, pour diagnostiquer les problèmes de rendu.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: Tkinter, interface graphique, diagnostic, test, composants</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python"># -*- coding: utf-8 -*-

import tkinter as tk
from tkinter import ttk, messagebox

class InteractiveTester:
    def __init__(self, root):
        self.root = root
        self.root.title("Outil de Diagnostic Interactif (v14)")
        self.root.geometry("900x700")
        self.root.configure(bg='#f0f0f0')

        self.status_label = tk.Label(
            self.root,
            text="Prêt. Cliquez sur les boutons pour construire l'interface.",
            bg='#d3d3d3', # Gris pour le différencier
            fg='black'
        )
        self.status_label.pack(fill=tk.X, side=tk.BOTTOM)

        # --- Cadre pour les boutons de test ---
        button_frame = tk.Frame(self.root, bg='#c0c0c0', padx=10, pady=10)
        button_frame.pack(fill=tk.X, side=tk.TOP)

        self.b1 = tk.Button(button_frame, text="1. Ajouter la barre de recherche", command=self.add_search_bar)
        self.b1.pack(side=tk.LEFT, padx=5)

        self.b2 = tk.Button(button_frame, text="2. Ajouter le tableau de résultats", command=self.add_results_table, state=tk.DISABLED)
        self.b2.pack(side=tk.LEFT, padx=5)
        
        # Cadre où les widgets seront ajoutés
        self.content_frame = tk.Frame(self.root, bg='#f0f0f0')
        self.content_frame.pack(expand=True, fill=tk.BOTH)


    def add_search_bar(self):
        """Teste l'ajout de la barre de recherche."""
        try:
            self.status_label.config(text="Ajout de la barre de recherche...")
            
            # Utilisation de .place() pour un positionnement absolu et simple
            tk.Label(self.content_frame, text="Mots-clés:", bg='#f0f0f0', fg='black').place(x=10, y=10)
            
            tk.Entry(self.content_frame, bg='white', fg='black', insertbackground='black').place(x=90, y=10, width=300)
            
            tk.Button(self.content_frame, text="Rechercher", highlightbackground='#f0f0f0').place(x=400, y=10)
            
            self.status_label.config(text="Barre de recherche ajoutée avec succès ! Passez à l'étape 2.")
            self.b1.config(state=tk.DISABLED, text="1. Barre de recherche OK")
            self.b2.config(state=tk.NORMAL)
            
        except Exception as e:
            messagebox.showerror("Erreur", f"Échec lors de l'ajout de la barre de recherche: {e}")
            self.status_label.config(text=f"Erreur à l'étape 1: {e}")

    def add_results_table(self):
        """Teste l'ajout du tableau de résultats (Treeview)."""
        try:
            self.status_label.config(text="Ajout du tableau de résultats...")
            
            # Cadre pour le tableau
            tree_frame = tk.Frame(self.content_frame)
            tree_frame.place(x=10, y=50, relwidth=0.97, relheight=0.9)

            style = ttk.Style()
            style.theme_use('aqua')
            
            tree = ttk.Treeview(tree_frame, columns=('col1', 'col2'), show='headings')
            tree.heading('col1', text='Colonne 1')
            tree.heading('col2', text='Colonne 2')
            
            vsb = ttk.Scrollbar(tree_frame, orient="vertical", command=tree.yview)
            tree.configure(yscrollcommand=vsb.set)

            tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
            vsb.pack(side=tk.RIGHT, fill=tk.Y)
            
            tree.insert('', 'end', values=('Test 1', 'Donnée A'))
            tree.insert('', 'end', values=('Test 2', 'Donnée B'))

            self.status_label.config(text="TOUT A FONCTIONNÉ ! Le problème est ailleurs.")
            self.b2.config(state=tk.DISABLED, text="2. Tableau OK")

        except Exception as e:
            messagebox.showerror("Erreur", f"ÉCHEC LORS DE L'AJOUT DU TABLEAU ! C'est le composant fautif.\n\nErreur: {e}")
            self.status_label.config(text=f"Erreur à l'étape 2: {e}")


if __name__ == "__main__":
    main_root = tk.Tk()
    app = InteractiveTester(main_root)
    main_root.mainloop()

</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>chercheur110725.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour classifierv1806.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">classifierv1806.py</h2>
                    <p class="text-gray-300 mt-1">Ce script Python organise automatiquement les fichiers d'un dossier, détecte les doublons et utilise une IA (Gemini) ainsi qu'une mémoire persistante pour la classification des fichiers, avec une validation utilisateur des catégories.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: organisation, fichiers, doublons, classification IA, mémoire</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">import os
import sys
import hashlib
import shutil
import json
import requests
from collections import defaultdict
import time

# --- Configuration de la Mémoire ---
MEMORY_FILE = os.path.join(os.path.expanduser('~'), 'Desktop', 'organizer_memory.json')

# =============================================================================
# --- FONCTIONS DE GESTION DE LA MÉMOIRE ---
# =============================================================================

def load_memory():
    """Charge la mémoire (catégories, map de noms, et map de hash)."""
    if os.path.exists(MEMORY_FILE):
        print("\nINFO: Fichier de mémoire trouvé. Chargement des connaissances antérieures...")
        with open(MEMORY_FILE, 'r', encoding='utf-8') as f:
            try:
                memory = json.load(f)
                # Assure que toutes les clés nécessaires existent
                memory.setdefault("learned_categories", [])
                memory.setdefault("classification_map_by_name", {})
                memory.setdefault("classification_map_by_hash", {})
                return memory
            except json.JSONDecodeError:
                pass # Fichier corrompu, on en crée un nouveau
    print("\nINFO: Aucun fichier de mémoire trouvé. Démarrage avec une table rase.")
    return {"learned_categories": [], "classification_map_by_name": {}, "classification_map_by_hash": {}}

def save_memory(data):
    """Sauvegarde la mémoire dans le fichier JSON."""
    print("\nMise à jour de la mémoire avec les nouvelles connaissances...")
    try:
        with open(MEMORY_FILE, 'w', encoding='utf-8') as f:
            json.dump(data, f, indent=4, ensure_ascii=False)
        print(f"Mémoire sauvegardée avec succès dans : {MEMORY_FILE}")
    except Exception as e:
        print(f"[ERREUR] Impossible de sauvegarder la mémoire : {e}")

# =============================================================================
# --- ÉTAPES 1 &amp; 2 (DOUBLONS) ---
# Le code est identique aux versions précédentes.
# =============================================================================

def calculate_hash(filepath, block_size=65536):
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while True:
                data = f.read(block_size)
                if not data:
                    break
                sha256.update(data)
        return sha256.hexdigest()
    except (IOError, FileNotFoundError):
        return None

def find_duplicates(folder):
    print(f"\n--- ÉTAPE 1: Recherche des doublons dans : {folder} ---")
    hashes = defaultdict(list)
    excluded_dirs = ["Doublons", "Classement_Final"]
    files_to_scan = [os.path.join(dp, fn) for dp, dn, fns in os.walk(folder) for fn in fns if not any(excluded in dp for excluded in excluded_dirs)]
    total_files = len(files_to_scan)
    if total_files == 0: return {}, []
    for i, filepath in enumerate(files_to_scan):
        try:
            sys.stdout.write(f"\rAnalyse des fichiers : {((i + 1) / total_files) * 100:.1f}%")
            sys.stdout.flush()
            if not os.path.islink(filepath) and os.path.getsize(filepath) &gt; 0:
                file_hash = calculate_hash(filepath)
                if file_hash: hashes[file_hash].append(filepath)
        except (FileNotFoundError, OSError): continue
    print("\nAnalyse des doublons terminée.")
    duplicates = {h: p for h, p in hashes.items() if len(p) &gt; 1}
    unique_files = [p[0] for h, p in hashes.items() if len(p) == 1]
    return duplicates, unique_files

def get_readability_score(filename):
    score = len(filename)
    if any(c.isalpha() for c in filename): score += 20
    if filename.split('.')[0].isdigit(): score -= 10
    return score

def process_duplicates_safely(duplicates, base_folder, desktop_path):
    if not duplicates:
        print("\n--- ÉTAPE 2: Traitement des doublons ---\nBonne nouvelle ! Aucun fichier en double à traiter.")
        return []
    print(f"\n--- ÉTAPE 2: Traitement automatique et protégé de {len(duplicates)} groupes de doublons ---")
    duplicates_folder = os.path.join(base_folder, "Doublons")
    os.makedirs(duplicates_folder, exist_ok=True)
    print(f"Les doublons non-protégés seront déplacés dans : {duplicates_folder}")
    files_kept = []
    for group_paths in duplicates.values():
        try:
            if desktop_path and any(p.startswith(desktop_path) for p in group_paths):
                file_to_keep = max((p for p in group_paths if p.startswith(desktop_path)), key=os.path.getmtime)
                final_path = file_to_keep
            else:
                file_to_keep = max(group_paths, key=os.path.getmtime)
                best_name = os.path.basename(max(group_paths, key=lambda p: get_readability_score(os.path.basename(p))))
                original_dir = os.path.dirname(file_to_keep)
                potential_new_path = os.path.join(original_dir, best_name)
                final_path = file_to_keep
                if file_to_keep != potential_new_path and not os.path.exists(potential_new_path):
                    os.rename(file_to_keep, potential_new_path)
                    final_path = potential_new_path
            files_kept.append(final_path)
            for path in group_paths:
                if path != file_to_keep and not (desktop_path and path.startswith(desktop_path)):
                    try: shutil.move(path, os.path.join(duplicates_folder, os.path.basename(path)))
                    except Exception as e: print(f"Erreur déplacement doublon {os.path.basename(path)}: {e}")
        except Exception as e: print(f"\nErreur traitement groupe doublons : {e}")
    print("\nTraitement des doublons terminé.")
    return files_kept

# =============================================================================
# --- ÉTAPE 3: CLASSIFICATION IA (AVEC SUPER-MÉMOIRE) ---
# =============================================================================

def learn_structure_from_path(path_to_learn):
    learned_categories = set()
    if not os.path.isdir(path_to_learn): return learned_categories
    print(f"Analyse de la structure de : {path_to_learn}...")
    for root, dirs, _ in os.walk(path_to_learn):
        for dir_name in dirs:
            if dir_name.startswith('.') or dir_name.lower() in ["attachments", "files", "images"]: continue
            clean_name = dir_name.replace('_', ' ').strip()
            if len(clean_name) &gt; 3: learned_categories.add(clean_name)
    return learned_categories

def propose_categories_with_ai(files_for_ai, learned_categories, api_key):
    if not files_for_ai: return {}
    print(f"\n--- ÉTAPE 3b: Interrogation de l'IA pour {len(files_for_ai)} nouveaux fichiers ---")
    BATCH_SIZE, MAX_RETRIES, BACKOFF_FACTOR = 75, 3, 2
    ai_classifications = {}
    total_files = len(files_for_ai)
    for i in range(0, total_files, BATCH_SIZE):
        batch_files = files_for_ai[i:i + BATCH_SIZE]
        batch_filenames = [os.path.basename(f) for f in batch_files]
        current_batch_num = (i // BATCH_SIZE) + 1
        total_batches = (total_files + BATCH_SIZE - 1) // BATCH_SIZE
        print(f"\nTraitement du lot {current_batch_num}/{total_batches}...")
        prompt = (f"En te basant sur cette liste de catégories apprises : {list(learned_categories)}. Pour la liste de noms de fichiers suivante : {json.dumps(batch_filenames)}. Propose la catégorie la plus pertinente pour CHAQUE fichier. Si aucune catégorie ne correspond, invente une catégorie pertinente et concise (2-4 mots). Réponds UNIQUEMENT avec un objet JSON où chaque clé est un nom de fichier et sa valeur est la catégorie proposée.")
        payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
        apiUrl = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={api_key}"
        for attempt in range(MAX_RETRIES):
            try:
                response = requests.post(apiUrl, json=payload, timeout=90)
                response.raise_for_status()
                json_text = response.json()['candidates'][0]['content']['parts'][0]['text']
                json_text = json_text.strip().replace("```json", "").replace("```", "")
                batch_classifications = json.loads(json_text)
                ai_classifications.update(batch_classifications)
                print(f"Lot {current_batch_num} traité avec succès.")
                break
            except requests.exceptions.HTTPError as err:
                if err.response.status_code in [500, 503, 504] and (attempt + 1) &lt; MAX_RETRIES:
                    wait_time = BACKOFF_FACTOR * (2 ** attempt)
                    print(f"  -&gt; Échec temporaire (tentative {attempt + 1}/{MAX_RETRIES}): {err.response.status_code}. Nouvelle tentative dans {wait_time}s...")
                    time.sleep(wait_time)
                else: print(f"\n[ERREUR HTTP] Échec final du lot {current_batch_num}. Ce lot sera ignoré."); break
            except Exception as e: print(f"\n[ERREUR] Échec du lot {current_batch_num} : {e}. Ce lot sera ignoré."); break
        time.sleep(1)
    return ai_classifications

# =============================================================================
# --- ÉTAPES 4 &amp; 5 (VALIDATION, ORGANISATION) ---
# =============================================================================

def validate_categories(classification_plan):
    if not classification_plan: return set()
    proposed_categories = sorted(list(set(classification_plan.values())))
    print("\n--- ÉTAPE 4: Validation des catégories proposées ---")
    for i, cat_name in enumerate(proposed_categories): print(f"  {i+1}) {cat_name}")
    validated_categories = set()
    while True:
        try:
            choices_str = input("\nEntrez les numéros des catégories à conserver (ex: 1,3,4), ou 'toutes' : ")
            if choices_str.lower() == 'toutes': return set(proposed_categories)
            chosen_indices = [int(i.strip()) - 1 for i in choices_str.split(',')]
            for index in chosen_indices:
                if 0 &lt;= index &lt; len(proposed_categories): validated_categories.add(proposed_categories[index])
            if validated_categories: print("\nCatégories validées :", ", ".join(validated_categories)); return validated_categories
        except ValueError: print("[ERREUR] Entrée invalide.")

def execute_final_organization(base_folder, classification_plan, validated_categories, desktop_path):
    print("\n--- ÉTAPE 5: Organisation finale des fichiers ---")
    output_root = os.path.join(base_folder, "Classement_Final")
    os.makedirs(output_root, exist_ok=True)
    print(f"Les fichiers seront déplacés et organisés dans : {output_root}")
    for cat in validated_categories: os.makedirs(os.path.join(output_root, cat), exist_ok=True)
    unclassified_dir = os.path.join(output_root, "Non Classé")
    os.makedirs(unclassified_dir, exist_ok=True)
    for i, (original_path, category) in enumerate(classification_plan.items()):
        sys.stdout.write(f"\rDéplacement des fichiers : {((i + 1) / len(classification_plan)) * 100:.1f}%")
        sys.stdout.flush()
        if os.path.exists(original_path) and not (desktop_path and original_path.startswith(desktop_path)):
            target_dir = os.path.join(output_root, category) if category in validated_categories else unclassified_dir
            try: shutil.move(original_path, os.path.join(target_dir, os.path.basename(original_path)))
            except Exception as e: print(f"\n[ERREUR] Impossible de déplacer {original_path}. Erreur: {e}")
    print(f"\n\nL'organisation finale est terminée !\nNote : les fichiers sur votre Bureau n'ont pas été déplacés.")

# =============================================================================
# --- FONCTION PRINCIPALE (main) ---
# =============================================================================

def main():
    try:
        print("--- Assistant d'Organisation v15 (Super-Mémoire) ---")
        memory = load_memory()
        
        home = os.path.expanduser('~')
        desktop_path = next((p for p in [os.path.join(home, 'Desktop'), os.path.join(home, 'Bureau')] if os.path.isdir(p)), "")
        if desktop_path: print(f"Règle de protection activée pour le Bureau : {desktop_path}")
        
        api_key = input("Veuillez coller votre clé API Google AI Studio : ").strip()
        
        obsidian_path = input("1. (Optionnel) Glissez-déposez votre coffre Obsidian pour mettre à jour la mémoire : ").strip("'\"")
        notion_path = input("2. (Optionnel) Glissez-déposez votre export Notion pour mettre à jour la mémoire : ").strip("'\"")
        
        learned_from_folders = learn_structure_from_path(obsidian_path)
        learned_from_folders.update(learn_structure_from_path(notion_path))
        all_learned_categories = set(memory["learned_categories"]) | learned_from_folders
        if all_learned_categories: print(f"\nConnaissances actuelles : {len(all_learned_categories)} catégories mémorisées.")

        folder_path = input("\n3. Maintenant, glissez-déposez le dossier principal à analyser : ").strip("'\"")
        if not os.path.isdir(folder_path): return

        duplicates, unique_files = find_duplicates(folder_path)
        files_kept_after_dedup = process_duplicates_safely(duplicates, folder_path, desktop_path)
        all_files_to_classify = list(set(unique_files + files_kept_after_dedup))
        all_files_to_classify = [f for f in all_files_to_classify if os.path.exists(f)]

        if not all_files_to_classify:
            print("\nIl ne reste aucun fichier à classer. Opération terminée.")
            return

        # --- NOUVELLE LOGIQUE DE CLASSIFICATION AVEC SUPER-MÉMOIRE ---
        print("\n--- ÉTAPE 3a: Consultation de la mémoire pour la classification ---")
        classification_plan = {}
        files_for_ai = []
        map_by_name = memory["classification_map_by_name"]
        map_by_hash = memory["classification_map_by_hash"]
        
        for i, f_path in enumerate(all_files_to_classify):
            sys.stdout.write(f"\rConsultation mémoire : {((i + 1) / len(all_files_to_classify)) * 100:.1f}%")
            sys.stdout.flush()
            f_name = os.path.basename(f_path)
            
            # Priorité 1: Mémoire par nom de fichier
            if f_name in map_by_name:
                classification_plan[f_path] = map_by_name[f_name]
                continue

            # Priorité 2: Mémoire par contenu (hash)
            file_hash = calculate_hash(f_path)
            if file_hash in map_by_hash:
                classification_plan[f_path] = map_by_hash[file_hash]
                continue
            
            # Si inconnu, on l'ajoute à la liste pour l'IA
            files_for_ai.append(f_path)

        print(f"\n{len(classification_plan)} fichiers classés instantanément grâce à la mémoire.")

        if api_key and files_for_ai:
            ai_results_by_name = propose_categories_with_ai(files_for_ai, all_learned_categories, api_key)
            for f_path in files_for_ai:
                f_name = os.path.basename(f_path)
                classification_plan[f_path] = ai_results_by_name.get(f_name, "Non Classé")
        else:
             for f_path in files_for_ai: classification_plan[f_path] = "Non Classé"

        # --- Validation et Exécution ---
        validated_categories = validate_categories(classification_plan)
        if not validated_categories: print("\nAucune catégorie validée. Opération annulée."); return

        confirm = input("\nPrêt à lancer l'organisation finale ? (o/n) &gt; ").lower()
        if confirm == 'o':
            execute_final_organization(folder_path, classification_plan, validated_categories, desktop_path)
            
            # --- Mise à jour finale de la mémoire ---
            memory["learned_categories"] = sorted(list(validated_categories | all_learned_categories))
            for f_path, category in classification_plan.items():
                if category in validated_categories:
                    f_name = os.path.basename(f_path)
                    f_hash = calculate_hash(f_path)
                    memory["classification_map_by_name"][f_name] = category
                    if f_hash: memory["classification_map_by_hash"][f_hash] = category
            save_memory(memory)
        else:
            print("\nOpération finale annulée. La mémoire n'a pas été mise à jour.")

    except (EOFError, KeyboardInterrupt): print("\n\nProgramme interrompu par l'utilisateur.")
    except Exception as e:
        print(f"\nUne erreur inattendue est survenue : {e}")
        import traceback
        traceback.print_exc()

if __name__ == "__main__":
    main()
</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>classifierv1806.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour Copie de Backend Flask_app.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">Copie de Backend Flask_app.py</h2>
                    <p class="text-gray-300 mt-1">Le code initialise une API Flask pour la vérification de crédibilité via un système externe, gérant les requêtes client et les erreurs d'importation du module de vérification.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: Flask, API REST, vérification, crédibilité, système</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"colab":{"background_save":true,"base_uri":"https://localhost:8080/"},"id":"Q4bEq6K9LsdE"},"outputs":[{"name":"stdout","output_type":"stream","text":["Error: Could not import CredibilityVerificationSystem.\n","Please ensure 'credibility_system.py' exists and is in the correct path.\n","Current sys.path: ['/content', '/env/python', '/usr/lib/python311.zip', '/usr/lib/python3.11', '/usr/lib/python3.11/lib-dynload', '', '/usr/local/lib/python3.11/dist-packages', '/usr/lib/python3/dist-packages', '/usr/local/lib/python3.11/dist-packages/IPython/extensions', '/usr/local/lib/python3.11/dist-packages/setuptools/_vendor', '/root/.ipython']\n","CredibilityVerificationSystem module not found. Flask app will start, but /api/verify will not work.\n","Flask app created and CORS enabled.\n","Starting Flask development server...\n"," * Serving Flask app '__main__'\n"," * Debug mode: on\n"]},{"name":"stderr","output_type":"stream","text":["INFO:werkzeug:\u001b[31m\u001b[1mWARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.\u001b[0m\n"," * Running on all addresses (0.0.0.0)\n"," * Running on http://127.0.0.1:5000\n"," * Running on http://172.28.0.12:5000\n","INFO:werkzeug:\u001b[33mPress CTRL+C to quit\u001b[0m\n","INFO:werkzeug: * Restarting with stat\n"]}],"source":["# Import necessary libraries\n","from flask import Flask, request, jsonify\n","# Install flask_cors if not already installed\n","try:\n","    from flask_cors import CORS # To handle Cross-Origin Resource Sharing\n","except ImportError:\n","    print(\"flask_cors not found. Installing...\")\n","    !pip install flask_cors\n","    from flask_cors import CORS\n","    print(\"flask_cors installed successfully.\")\n","\n","import sys\n","import os\n","import traceback # To help with debugging errors\n","\n","# --- Configuration Import ---\n","# Add the directory containing 'credibility_system.py' to the Python path\n","# Adjust this path if your file structure is different\n","# Assumes 'credibility_system.py' is in the same directory as 'app.py'\n","# If it's elsewhere, provide the correct path.\n","# Example: sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'path_to_your_module')))\n","\n","# Initialize credibility_checker to None, so we can check if it was successfully imported\n","credibility_checker = None\n","\n","try:\n","    # Assuming your CredibilityVerificationSystem class is in a file named 'credibility_system.py'\n","    # in the same directory as this 'app.py' file.\n","    from credibility_system import CredibilityVerificationSystem\n","    print(\"Successfully imported CredibilityVerificationSystem.\")\n","    # --- Instantiate the System ---\n","    # Load models only once when the server starts\n","    # This can take time, so the server might be slow to start initially.\n","    print(\"Initializing CredibilityVerificationSystem... (This might take a moment)\")\n","    credibility_checker = CredibilityVerificationSystem()\n","    print(\"CredibilityVerificationSystem initialized.\")\n","\n","except ImportError:\n","    print(\"Error: Could not import CredibilityVerificationSystem.\")\n","    print(\"Please ensure 'credibility_system.py' exists and is in the correct path.\")\n","    print(f\"Current sys.path: {sys.path}\")\n","    # Removed sys.exit() to avoid stopping the notebook execution\n","    # The credibility_checker will remain None, and the API endpoint\n","    # will need to handle this case.\n","    print(\"CredibilityVerificationSystem module not found. Flask app will start, but /api/verify will not work.\")\n","except Exception as e:\n","    print(f\"Error initializing CredibilityVerificationSystem: {e}\")\n","    traceback.print_exc() # Print detailed error traceback\n","    # Removed sys.exit()\n","    print(\"Failed to initialize credibility system. Flask app will start, but /api/verify will not work.\")\n","\n","\n","# --- Flask App Initialization ---\n","app = Flask(__name__)\n","# IMPORTANT: Enable CORS to allow requests from your HTML file (frontend)\n","# For development, allow all origins ('*'). For production, restrict this\n","# to the actual domain where your frontend is hosted.\n","CORS(app)\n","print(\"Flask app created and CORS enabled.\")\n","\n","# --- API Route Definition ---\n","@app.route('/api/verify', methods=['POST'])\n","def verify_endpoint():\n","    \"\"\"\n","    API endpoint to receive input data and return credibility analysis.\n","    Expects a JSON payload with the key 'input_data'.\n","    \"\"\"\n","    print(\"\\nReceived request on /api/verify\")\n","\n","    # Check if the credibility system was initialized successfully\n","    if credibility_checker is None:\n","        print(\"Error: Credibility verification system not initialized.\")\n","        return jsonify({\"error\": \"Credibility verification system is not available.\"}), 503 # Service Unavailable\n","\n","\n","    # 1. Get data from the request\n","    if not request.is_json:\n","        print(\"Error: Request is not JSON\")\n","        return jsonify({\"error\": \"Request must be JSON\"}), 400 # Bad Request\n","\n","    data = request.get_json()\n","    input_data = data.get('input_data', None)\n","\n","    if not input_data or not isinstance(input_data, str) or not input_data.strip():\n","        print(\"Error: 'input_data' is missing or invalid\")\n","        return jsonify({\"error\": \"'input_data' field is required and must be a non-empty string\"}), 400\n","\n","    print(f\"Processing input: {input_data[:100]}...\") # Log received data (truncated)\n","\n","    # 2. Call the credibility verification system\n","    try:\n","        # Use the pre-initialized checker instance\n","        results = credibility_checker.verify_information(input_data)\n","        print(\"Verification successful.\")\n","        # Check if the verification itself returned an error structure\n","        if isinstance(results, dict) and 'error' in results:\n","             print(f\"Verification returned an error: {results['error']}\")\n","             # Return the specific error from the verification logic\n","             # Use 400 (Bad Request) or potentially 500 (Internal Server Error)\n","             # depending on the nature of the error. 400 is often suitable if\n","             # the input caused the issue (e.g., invalid URL, empty text after processing).\n","             return jsonify(results), 400\n","\n","        # 3. Return the results as JSON\n","        print(f\"Returning report with score: {results.get('scoreCredibilite', 'N/A')}\")\n","        return jsonify(results), 200 # OK\n","\n","    except Exception as e:\n","        # Catch any unexpected errors during verification\n","        print(f\"Error during verification process: {e}\")\n","        traceback.print_exc() # Log the full error traceback for debugging\n","        # Return a generic server error message\n","        return jsonify({\"error\": \"An internal server error occurred during analysis.\"}), 500 # Internal Server Error\n","\n","\n","# --- Run the App (for development) ---\n","if __name__ == '__main__':\n","    # Runs the Flask development server.\n","    # host='0.0.0.0' makes it accessible on your network (useful for testing from other devices)\n","    # debug=True provides automatic reloading and more detailed error pages (DO NOT use in production)\n","    print(\"Starting Flask development server...\")\n","    # Flask's development server might restart multiple times when debug=True,\n","    # leading to re-execution of the code cell. This is normal behavior.\n","    app.run(host='0.0.0.0', port=5000, debug=True)"]}],"metadata":{"colab":{"name":"","provenance":[{"file_id":"1H6oPi2o3xKgNC1ZYv5rDnekxNJ-bYkHC","timestamp":1745620655445}],"version":""},"kernelspec":{"display_name":"Python 3","name":"python3"}},"nbformat":4,"nbformat_minor":0}</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>Copie de Backend Flask_app.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour dc706.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">dc706.py</h2>
                    <p class="text-gray-300 mt-1">Ce script Python organise des fichiers en identifiant et suggérant la suppression des doublons, en les renommant intelligemment, puis en les classant et copiant dans des dossiers thématiques basés sur des catégories de cours UQAM, potentiellement via une API d'IA.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: fichiers, doublons, classement, organisation, UQAM</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">import os
import sys
import hashlib
import time
import json
import requests
import shutil  # Module pour copier les fichiers
from collections import defaultdict

# --- Fonctions de base (trouver les doublons) ---

def calculate_hash(filepath, block_size=65536):
    """Calcule le hash SHA-256 d'un fichier."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while True:
                data = f.read(block_size)
                if not data:
                    break
                sha256.update(data)
        return sha256.hexdigest()
    except IOError:
        return None

def find_duplicates(folder):
    """Trouve les fichiers en double."""
    print(f"\nÉtape 1: Recherche des doublons dans : {folder}")
    hashes = defaultdict(list)
    total_files = sum(len(files) for _, _, files in os.walk(folder))
    scanned_files = 0

    if total_files == 0:
        print("\nDossier vide ou inaccessible.")
        return {}

    for dirpath, _, filenames in os.walk(folder):
        for filename in filenames:
            scanned_files += 1
            filepath = os.path.join(dirpath, filename)
            if not os.path.islink(filepath) and os.path.getsize(filepath) &gt; 0:
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes[file_hash].append(filepath)
            
            progress = (scanned_files / total_files) * 100
            sys.stdout.write(f"\rProgression: {progress:.1f}% ({scanned_files}/{total_files} fichiers)")
            sys.stdout.flush()

    print("\nRecherche des doublons terminée.\n")
    return {h: p for h, p in hashes.items() if len(p) &gt; 1}

# --- Fonctions de renommage et suggestion de suppression ---

def get_readability_score(filename):
    """Attribue un score à un nom de fichier."""
    score = len(filename)
    if any(c.isalpha() for c in filename):
        score += 20
    if filename.split('.')[0].isdigit():
        score -= 10
    return score

def get_best_filename(filepaths):
    """Choisit le meilleur nom de fichier."""
    return os.path.basename(max(filepaths, key=lambda p: (get_readability_score(os.path.basename(p)), len(p))))

def process_duplicates_and_suggest_deletions(duplicates):
    """Effectue le renommage intelligent et liste les doublons à supprimer."""
    if not duplicates:
        print("\nBonne nouvelle ! Aucun fichier en double n'a été trouvé.")
        return []

    print(f"Étape 2: Traitement de {len(duplicates)} groupes de doublons (Renommage intelligent)")
    
    files_to_delete = []
    files_kept = []

    for group_paths in duplicates.values():
        group_paths.sort()
        original_to_keep = group_paths[0]
        original_dir = os.path.dirname(original_to_keep)
        
        best_name = get_best_filename(group_paths)
        final_path = os.path.join(original_dir, best_name)

        if original_to_keep != final_path:
            try:
                if os.path.exists(final_path):
                    final_path = original_to_keep
                else:
                    os.rename(original_to_keep, final_path)
                    print(f"  - Renommé : '{os.path.basename(original_to_keep)}' -&gt; '{best_name}'")
            except OSError as e:
                print(f"  - ERREUR de renommage : {e}. Le nom original est conservé.")
                final_path = original_to_keep
        
        files_kept.append(final_path)

        # Ajoute les autres fichiers à la liste de suppression
        for path_to_delete in group_paths:
            if path_to_delete != original_to_keep:
                files_to_delete.append(path_to_delete)

    print("\nNettoyage des noms terminé.")
    if files_to_delete:
        print("\nLes fichiers suivants sont des doublons et peuvent être supprimés manuellement :")
        for f in files_to_delete:
            print(f"  - {f}")
    
    return files_kept

# --- Fonctions de classement par IA (version améliorée) ---

def classify_file_custom(filepath, categories):
    """Utilise l'IA pour classer un fichier selon des catégories spécifiques UQAM."""
    try:
        filename = os.path.basename(filepath).lower()
        
        # Tentative de classification directe par mots-clés
        for category_name, keywords in categories.items():
            for keyword in keywords:
                if keyword in filename:
                    return category_name

        # Si aucune correspondance, on demande à l'IA
        prompt = (f"Le nom du fichier est '{filename}'. Basé sur les sigles de cours de l'UQAM, "
                  f"classe ce fichier dans l'une de ces catégories : {list(categories.keys())}. "
                  "Exemples: 'projet_dic9345.pdf' va dans 'UQAM - DIC9345 - TALN'. "
                  "'resume_these_v3.docx' va dans 'Thèse de doctorat'. "
                  "Réponds uniquement avec le nom de la catégorie. Si incertain, réponds 'À Classer Manuellement'.")

        payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
        apiKey = ""
        apiUrl = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={apiKey}"
        
        response = requests.post(apiUrl, json=payload, timeout=15)
        response.raise_for_status()
        
        result = response.json()
        category = result.get('candidates')[0]['content']['parts'][0]['text'].strip()
        
        if category in categories:
            return category
        else:
            return "À Classer Manuellement"
            
    except Exception:
        return "À Classer Manuellement"

def classify_and_copy_files(base_folder, all_files):
    """Classe tous les fichiers et en fait une copie dans des dossiers thématiques."""
    print("\nÉtape 3: Classement thématique des fichiers (création de copies)")
    
    # NOUVELLES CATÉGORIES BASÉES SUR VOS IMAGES
    uqam_categories = {
        "UQAM - DIC9251 - Modélisation": ["dic-9251", "dic9251", "modélisation"],
        "UQAM - DIC9335 - Science du web": ["dic-9335", "dic9335", "science du web"],
        "UQAM - DIC9270 - Séminaires": ["dic-9270", "dic9270", "séminaire"],
        "UQAM - DIC9345 - TALN": ["dic-9345", "dic9345", "taln", "langage naturel"],
        "UQAM - DIC9401 - Examen Général": ["dic-9401", "dic9401", "examen général"],
        "UQAM - DIC9411 - Projet Recherche": ["dic-9411", "dic9411", "projet de recherche"],
        "UQAM - DIC9150 - Concepts Fondamentaux": ["dic-9150", "dic9150"],
        "UQAM - DIC9001 - Fondements &amp; Tendances": ["dic-9001", "dic9001"],
        "UQAM - DIC9351 - Apprentissage Machine": ["dic-9351", "dic9351", "apprentissage machine", "machine learning"],
        "Thèse de doctorat": ["thèse", "these", "dic-9500", "dic9500"],
        "À Classer Manuellement": []
    }

    copies_folder = os.path.join(base_folder, "Classement (Copies)")
    os.makedirs(copies_folder, exist_ok=True)
    
    print(f"Les copies classées seront créées dans : {copies_folder}")
    
    total_files_to_classify = len(all_files)
    for i, filepath in enumerate(all_files):
        if not os.path.exists(filepath):
            continue

        progress = ((i + 1) / total_files_to_classify) * 100
        sys.stdout.write(f"\rClassement et copie: {progress:.1f}% - {os.path.basename(filepath)}")
        sys.stdout.flush()

        category = classify_file_custom(filepath, uqam_categories)
        
        target_dir = os.path.join(copies_folder, category)
        os.makedirs(target_dir, exist_ok=True)
        
        try:
            # COPIE DU FICHIER AU LIEU DE DÉPLACEMENT
            shutil.copy2(filepath, target_dir)
        except Exception as e:
            print(f"\nErreur lors de la copie de {filepath} : {e}")
            
    print("\n\nLe classement et la création des copies sont terminés !")

# --- Fonction principale ---

def main():
    try:
        folder_path = input("Veuillez glisser-déposer le dossier à analyser ici, puis appuyez sur Entrée : ").strip()
        folder_path = folder_path.replace('\\ ', ' ').strip().strip("'\"")

        if not os.path.isdir(folder_path):
            print("\nErreur : Le chemin fourni n'est pas un dossier valide.")
            return

        duplicates_found = find_duplicates(folder_path)
        process_duplicates_and_suggest_deletions(duplicates_found)

        print("\nPréparation pour l'étape de classement...")
        # Récupère tous les fichiers restants pour le classement
        all_files_in_folder = set()
        for dirpath, _, filenames in os.walk(folder_path):
            if "Classement (Copies)" in dirpath: # Ignore le dossier de destination
                continue
            for f in filenames:
                all_files_in_folder.add(os.path.join(dirpath, f))
        
        final_list_of_files = [f for f in all_files_in_folder if os.path.exists(f)]

        if final_list_of_files:
            classify_and_copy_files(folder_path, final_list_of_files)
        else:
            print("\nAucun fichier à classer.")

    except (EOFError, KeyboardInterrupt):
        print("\nProgramme interrompu par l'utilisateur.")
    except Exception as e:
        print(f"\nUne erreur inattendue est survenue : {e}")

if __name__ == "__main__":
    main()
</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>dc706.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour dcv3.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">dcv3.py</h2>
                    <p class="text-gray-300 mt-1">Ce script Python gère les fichiers d'un répertoire en identifiant et supprimant les doublons, puis en organisant les fichiers restants par catégorie thématique à l'aide d'une IA.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: dédoublonnage, classement, fichiers, intelligence artificielle, organisation</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">import os
import sys
import hashlib
import time
import json
import requests # Utilise la bibliothèque standard pour les requêtes HTTP
from collections import defaultdict

# --- Fonctions de base (trouver les doublons) ---

def calculate_hash(filepath, block_size=65536):
    """Calcule le hash SHA-256 d'un fichier."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while True:
                data = f.read(block_size)
                if not data:
                    break
                sha256.update(data)
        return sha256.hexdigest()
    except IOError:
        return None

def find_duplicates(folder):
    """Trouve les fichiers en double et retourne un dictionnaire de doublons."""
    print(f"\nÉtape 1: Recherche des doublons dans : {folder}")
    hashes = defaultdict(list)
    total_files = sum(len(files) for _, _, files in os.walk(folder))
    scanned_files = 0

    if total_files == 0:
        print("\nDossier vide ou inaccessible.")
        return {}

    for dirpath, _, filenames in os.walk(folder):
        for filename in filenames:
            scanned_files += 1
            filepath = os.path.join(dirpath, filename)
            if not os.path.islink(filepath) and os.path.getsize(filepath) &gt; 0:
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes[file_hash].append(filepath)
            
            progress = (scanned_files / total_files) * 100
            sys.stdout.write(f"\rProgression: {progress:.1f}% ({scanned_files}/{total_files} fichiers)")
            sys.stdout.flush()

    print("\nRecherche des doublons terminée.\n")
    return {h: p for h, p in hashes.items() if len(p) &gt; 1}

# --- Fonctions de renommage intelligent ---

def get_readability_score(filename):
    """Attribue un score à un nom de fichier pour déterminer s'il est lisible."""
    score = len(filename)
    if any(c.isalpha() for c in filename):
        score += 20
    if filename.split('.')[0].isdigit():
        score -= 10
    return score

def get_best_filename(filepaths):
    """Choisit le meilleur nom de fichier parmi une liste de doublons."""
    # On trie d'abord par score de lisibilité, puis par longueur comme bris d'égalité
    return os.path.basename(max(filepaths, key=lambda p: (get_readability_score(os.path.basename(p)), len(p))))


def process_and_delete_duplicates(duplicates):
    """Gère le renommage intelligent et la suppression des doublons."""
    if not duplicates:
        print("Bonne nouvelle ! Aucun fichier en double n'a été trouvé.")
        return []

    print(f"Étape 2: Traitement de {len(duplicates)} groupes de doublons (renommage et suppression)")
    
    try:
        choice = input("Voulez-vous renommer intelligemment et supprimer les doublons ? (o/n) : ").lower()
        if choice != 'o':
            print("Opération annulée.")
            all_files = set()
            for paths in duplicates.values():
                all_files.update(paths)
            return list(all_files)
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return []

    files_kept = []
    for group_paths in duplicates.values():
        group_paths.sort()
        original_path = group_paths[0]
        original_dir = os.path.dirname(original_path)
        
        best_name = get_best_filename(group_paths)
        final_path = os.path.join(original_dir, best_name)

        if original_path != final_path:
            try:
                if os.path.exists(final_path):
                    print(f"  - AVERTISSEMENT: '{best_name}' existe déjà. Le renommage est ignoré.")
                    final_path = original_path
                else:
                    os.rename(original_path, final_path)
                    print(f"  - Renommé : '{os.path.basename(original_path)}' -&gt; '{best_name}'")
            except OSError as e:
                print(f"  - ERREUR de renommage : {e}. Le nom original est conservé.")
                final_path = original_path

        files_kept.append(final_path)

        for path_to_delete in group_paths:
            if path_to_delete != original_path:
                try:
                    os.remove(path_to_delete)
                except OSError as e:
                    print(f"  - ERREUR de suppression de {path_to_delete}: {e}")
    
    print("\nNettoyage des doublons terminé.")
    return files_kept

# --- Fonctions de classement par IA ---

def classify_file_gemini(filepath, categories):
    """Utilise l'API Gemini pour deviner la catégorie d'un fichier."""
    try:
        filename = os.path.basename(filepath)
        prompt = f"Analyse ce nom de fichier '{filename}' et classe-le dans l'une de ces catégories : {categories}. Réponds uniquement avec le nom exact de la catégorie. Si incertain, réponds 'Autre'."
        
        payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
        apiKey = "" # Aucune clé nécessaire pour ce modèle dans cet environnement
        apiUrl = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={apiKey}"
        
        # Appel réseau standard avec la bibliothèque requests
        response = requests.post(apiUrl, json=payload, timeout=10) # Timeout de 10s
        response.raise_for_status() # Lève une erreur si la requête échoue (ex: 404, 500)
        
        result = response.json()
        
        category = result.get('candidates')[0]['content']['parts'][0]['text'].strip()
        # Valide que la catégorie retournée par l'IA est bien dans notre liste
        if category in categories:
            return category
        else:
            return "Autre"
            
    except requests.exceptions.RequestException as e:
        # print(f"\nErreur réseau pour {filename}: {e}")
        return "Autre"
    except (KeyError, IndexError, Exception) as e:
        # print(f"\nErreur de traitement de la réponse API pour {filename}: {e}")
        return "Autre"

def classify_and_move_files(base_folder, all_files):
    """Classe tous les fichiers restants et les déplace."""
    print("\nÉtape 3: Classement thématique des fichiers restants par IA")
    try:
        choice = input("Voulez-vous lancer le classement automatique ? (Cela peut prendre du temps) (o/n) : ").lower()
        if choice != 'o':
            print("Classement ignoré. Le programme est terminé.")
            return
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return

    categories = ["Factures", "Recherche", "Contrats", "Photos", "Personnel", "Travail", "Admin", "Projets", "Autre"]
    classified_folder = os.path.join(base_folder, "Fichiers Classés")
    os.makedirs(classified_folder, exist_ok=True)
    
    print(f"Les fichiers seront classés dans : {classified_folder}")
    print("Catégories utilisées :", ", ".join(categories))
    
    total_files_to_classify = len(all_files)
    for i, filepath in enumerate(all_files):
        if not os.path.exists(filepath):
            continue

        progress = ((i + 1) / total_files_to_classify) * 100
        sys.stdout.write(f"\rClassement: {progress:.1f}% ({i+1}/{total_files_to_classify}) - {os.path.basename(filepath)}")
        sys.stdout.flush()

        category = classify_file_gemini(filepath, categories)
        
        target_dir = os.path.join(classified_folder, category)
        os.makedirs(target_dir, exist_ok=True)
        
        try:
            target_path = os.path.join(target_dir, os.path.basename(filepath))
            if os.path.exists(target_path):
                base, ext = os.path.splitext(os.path.basename(filepath))
                target_path = os.path.join(target_dir, f"{base}_{int(time.time())}{ext}")
            
            os.rename(filepath, target_path)
        except OSError as e:
            print(f"\nErreur lors du déplacement de {filepath} : {e}")
            
    print("\nClassement thématique terminé !")

# --- Fonction principale ---

def main():
    try:
        folder_path = input("Veuillez glisser-déposer le dossier à analyser ici, puis appuyez sur Entrée : ").strip()
        folder_path = folder_path.replace('\\ ', ' ').strip().strip("'\"")

        if not os.path.isdir(folder_path):
            print("\nErreur : Le chemin fourni n'est pas un dossier valide.")
            return

        duplicates_found = find_duplicates(folder_path)
        files_kept = process_and_delete_duplicates(duplicates_found)

        # Récupère tous les fichiers restants pour le classement
        all_files_in_folder = set()
        for dirpath, _, filenames in os.walk(folder_path):
            if "Fichiers Classés" in dirpath:
                continue
            for f in filenames:
                all_files_in_folder.add(os.path.join(dirpath, f))
        
        final_list_of_files = list(all_files_in_folder)

        if final_list_of_files:
            classify_and_move_files(folder_path, final_list_of_files)
        else:
            print("\nAucun fichier à classer.")

    except (EOFError, KeyboardInterrupt):
        print("\nProgramme interrompu par l'utilisateur.")
    except Exception as e:
        print(f"\nUne erreur inattendue est survenue : {e}")

if __name__ == "__main__":
    main()

import os
import sys
import hashlib
import time
import json
import requests # Utilise la bibliothèque standard pour les requêtes HTTP
from collections import defaultdict

# --- Fonctions de base (trouver les doublons) ---

def calculate_hash(filepath, block_size=65536):
    """Calcule le hash SHA-256 d'un fichier."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while True:
                data = f.read(block_size)
                if not data:
                    break
                sha256.update(data)
        return sha256.hexdigest()
    except IOError:
        return None

def find_duplicates(folder):
    """Trouve les fichiers en double et retourne un dictionnaire de doublons."""
    print(f"\nÉtape 1: Recherche des doublons dans : {folder}")
    hashes = defaultdict(list)
    total_files = sum(len(files) for _, _, files in os.walk(folder))
    scanned_files = 0

    if total_files == 0:
        print("\nDossier vide ou inaccessible.")
        return {}

    for dirpath, _, filenames in os.walk(folder):
        for filename in filenames:
            scanned_files += 1
            filepath = os.path.join(dirpath, filename)
            if not os.path.islink(filepath) and os.path.getsize(filepath) &gt; 0:
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes[file_hash].append(filepath)
            
            progress = (scanned_files / total_files) * 100
            sys.stdout.write(f"\rProgression: {progress:.1f}% ({scanned_files}/{total_files} fichiers)")
            sys.stdout.flush()

    print("\nRecherche des doublons terminée.\n")
    return {h: p for h, p in hashes.items() if len(p) &gt; 1}

# --- Fonctions de renommage intelligent ---

def get_readability_score(filename):
    """Attribue un score à un nom de fichier pour déterminer s'il est lisible."""
    score = len(filename)
    if any(c.isalpha() for c in filename):
        score += 20
    if filename.split('.')[0].isdigit():
        score -= 10
    return score

def get_best_filename(filepaths):
    """Choisit le meilleur nom de fichier parmi une liste de doublons."""
    # On trie d'abord par score de lisibilité, puis par longueur comme bris d'égalité
    return os.path.basename(max(filepaths, key=lambda p: (get_readability_score(os.path.basename(p)), len(p))))


def process_and_delete_duplicates(duplicates):
    """Gère le renommage intelligent et la suppression des doublons."""
    if not duplicates:
        print("Bonne nouvelle ! Aucun fichier en double n'a été trouvé.")
        return []

    print(f"Étape 2: Traitement de {len(duplicates)} groupes de doublons (renommage et suppression)")
    
    try:
        choice = input("Voulez-vous renommer intelligemment et supprimer les doublons ? (o/n) : ").lower()
        if choice != 'o':
            print("Opération annulée.")
            all_files = set()
            for paths in duplicates.values():
                all_files.update(paths)
            return list(all_files)
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return []

    files_kept = []
    for group_paths in duplicates.values():
        group_paths.sort()
        original_path = group_paths[0]
        original_dir = os.path.dirname(original_path)
        
        best_name = get_best_filename(group_paths)
        final_path = os.path.join(original_dir, best_name)

        if original_path != final_path:
            try:
                if os.path.exists(final_path):
                    print(f"  - AVERTISSEMENT: '{best_name}' existe déjà. Le renommage est ignoré.")
                    final_path = original_path
                else:
                    os.rename(original_path, final_path)
                    print(f"  - Renommé : '{os.path.basename(original_path)}' -&gt; '{best_name}'")
            except OSError as e:
                print(f"  - ERREUR de renommage : {e}. Le nom original est conservé.")
                final_path = original_path

        files_kept.append(final_path)

        for path_to_delete in group_paths:
            if path_to_delete != original_path:
                try:
                    os.remove(path_to_delete)
                except OSError as e:
                    print(f"  - ERREUR de suppression de {path_to_delete}: {e}")
    
    print("\nNettoyage des doublons terminé.")
    return files_kept

# --- Fonctions de classement par IA ---

def classify_file_gemini(filepath, categories):
    """Utilise l'API Gemini pour deviner la catégorie d'un fichier."""
    try:
        filename = os.path.basename(filepath)
        prompt = f"Analyse ce nom de fichier '{filename}' et classe-le dans l'une de ces catégories : {categories}. Réponds uniquement avec le nom exact de la catégorie. Si incertain, réponds 'Autre'."
        
        payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
        apiKey = "" # Aucune clé nécessaire pour ce modèle dans cet environnement
        apiUrl = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={apiKey}"
        
        # Appel réseau standard avec la bibliothèque requests
        response = requests.post(apiUrl, json=payload, timeout=10) # Timeout de 10s
        response.raise_for_status() # Lève une erreur si la requête échoue (ex: 404, 500)
        
        result = response.json()
        
        category = result.get('candidates')[0]['content']['parts'][0]['text'].strip()
        # Valide que la catégorie retournée par l'IA est bien dans notre liste
        if category in categories:
            return category
        else:
            return "Autre"
            
    except requests.exceptions.RequestException as e:
        # print(f"\nErreur réseau pour {filename}: {e}")
        return "Autre"
    except (KeyError, IndexError, Exception) as e:
        # print(f"\nErreur de traitement de la réponse API pour {filename}: {e}")
        return "Autre"

def classify_and_move_files(base_folder, all_files):
    """Classe tous les fichiers restants et les déplace."""
    print("\nÉtape 3: Classement thématique des fichiers restants par IA")
    try:
        choice = input("Voulez-vous lancer le classement automatique ? (Cela peut prendre du temps) (o/n) : ").lower()
        if choice != 'o':
            print("Classement ignoré. Le programme est terminé.")
            return
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return

    categories = ["Factures", "Recherche", "Contrats", "Photos", "Personnel", "Travail", "Admin", "Projets", "Autre"]
    classified_folder = os.path.join(base_folder, "Fichiers Classés")
    os.makedirs(classified_folder, exist_ok=True)
    
    print(f"Les fichiers seront classés dans : {classified_folder}")
    print("Catégories utilisées :", ", ".join(categories))
    
    total_files_to_classify = len(all_files)
    for i, filepath in enumerate(all_files):
        if not os.path.exists(filepath):
            continue

        progress = ((i + 1) / total_files_to_classify) * 100
        sys.stdout.write(f"\rClassement: {progress:.1f}% ({i+1}/{total_files_to_classify}) - {os.path.basename(filepath)}")
        sys.stdout.flush()

        category = classify_file_gemini(filepath, categories)
        
        target_dir = os.path.join(classified_folder, category)
        os.makedirs(target_dir, exist_ok=True)
        
        try:
            target_path = os.path.join(target_dir, os.path.basename(filepath))
            if os.path.exists(target_path):
                base, ext = os.path.splitext(os.path.basename(filepath))
                target_path = os.path.join(target_dir, f"{base}_{int(time.time())}{ext}")
            
            os.rename(filepath, target_path)
        except OSError as e:
            print(f"\nErreur lors du déplacement de {filepath} : {e}")
            
    print("\nClassement thématique terminé !")

# --- Fonction principale ---

def main():
    try:
        folder_path = input("Veuillez glisser-déposer le dossier à analyser ici, puis appuyez sur Entrée : ").strip()
        folder_path = folder_path.replace('\\ ', ' ').strip().strip("'\"")

        if not os.path.isdir(folder_path):
            print("\nErreur : Le chemin fourni n'est pas un dossier valide.")
            return

        duplicates_found = find_duplicates(folder_path)
        files_kept = process_and_delete_duplicates(duplicates_found)

        # Récupère tous les fichiers restants pour le classement
        all_files_in_folder = set()
        for dirpath, _, filenames in os.walk(folder_path):
            if "Fichiers Classés" in dirpath:
                continue
            for f in filenames:
                all_files_in_folder.add(os.path.join(dirpath, f))
        
        final_list_of_files = list(all_files_in_folder)

        if final_list_of_files:
            classify_and_move_files(folder_path, final_list_of_files)
        else:
            print("\nAucun fichier à classer.")

    except (EOFError, KeyboardInterrupt):
        print("\nProgramme interrompu par l'utilisateur.")
    except Exception as e:
        print(f"\nUne erreur inattendue est survenue : {e}")

if __name__ == "__main__":
    main()

</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>dcv3.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour Debate Analysis 1.ipynb -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">Debate Analysis 1.ipynb</h2>
                    <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">!pip install tweepy

# --- Nouvelle Cellule ---

# Import tweepy to work with the twitter API
import tweepy as tw

# Import numpy and pandas to work with dataframes
import numpy as np
import pandas as pd

# Import seaborn and matplotlib for viz
from matplotlib import pyplot as plt

# --- Nouvelle Cellule ---

consumer_key = ''
consumer_secret = ''
access_token = ''
access_token_secret = ''

# --- Nouvelle Cellule ---

# Authenticate
auth = tw.OAuthHandler(consumer_key, consumer_secret)
# Set Tokens
auth.set_access_token(access_token, access_token_secret)
# Instantiate API
api = tw.API(auth, wait_on_rate_limit=True)

# --- Nouvelle Cellule ---

hashtag = "#presidentialdebate"
query = tw.Cursor(api.search, q=hashtag).items(1000)
tweets = [{'Tweet':tweet.text, 'Timestamp':tweet.created_at} for tweet in query]
print(tweets)

# --- Nouvelle Cellule ---

df = pd.DataFrame.from_dict(tweets)
df.head()

# --- Nouvelle Cellule ---

trump_handle = ['DonaldTrump', 'Donald Trump', 'Donald', 'Trump', 'Trump\'s']
biden_handle = ['JoeBiden', 'Joe Biden', 'Joe', 'Biden', 'Biden\'s']

# --- Nouvelle Cellule ---

def identify_subject(tweet, refs):
    flag = 0 
    for ref in refs:
        if tweet.find(ref) != -1:
            flag = 1
    return flag

df['Trump'] = df['Tweet'].apply(lambda x: identify_subject(x, trump_handle)) 
df['Biden'] = df['Tweet'].apply(lambda x: identify_subject(x, biden_handle))
df.head(10)

# --- Nouvelle Cellule ---

# Import stopwords
import nltk
from nltk.corpus import stopwords

# Import textblob
from textblob import Word, TextBlob

# --- Nouvelle Cellule ---

nltk.download('stopwords')
nltk.download('wordnet')
stop_words = stopwords.words('english')
custom_stopwords = ['RT', '#PresidentialDebate']

# --- Nouvelle Cellule ---

def preprocess_tweets(tweet, custom_stopwords):
    processed_tweet = tweet
    processed_tweet.replace('[^\w\s]', '')
    processed_tweet = " ".join(word for word in processed_tweet.split() if word not in stop_words)
    processed_tweet = " ".join(word for word in processed_tweet.split() if word not in custom_stopwords)
    processed_tweet = " ".join(Word(word).lemmatize() for word in processed_tweet.split())
    return(processed_tweet)

df['Processed Tweet'] = df['Tweet'].apply(lambda x: preprocess_tweets(x, custom_stopwords))
df.head()

# --- Nouvelle Cellule ---

print('Base review\n', df['Tweet'][0])
print('\n------------------------------------\n')
print('Cleaned and lemmatized review\n', df['Processed Tweet'][0])

# --- Nouvelle Cellule ---

# Calculate polarity
df['polarity'] = df['Processed Tweet'].apply(lambda x: TextBlob(x).sentiment[0])
df['subjectivity'] = df['Processed Tweet'].apply(lambda x: TextBlob(x).sentiment[1])
df[['Processed Tweet', 'Biden', 'Trump', 'polarity', 'subjectivity']].head()

# --- Nouvelle Cellule ---

display(df[df['Trump']==1][['Trump','polarity','subjectivity']].groupby('Trump').agg([np.mean, np.max, np.min, np.median]))
df[df['Biden']==1][['Biden','polarity','subjectivity']].groupby('Biden').agg([np.mean, np.max, np.min, np.median])

# --- Nouvelle Cellule ---

biden = df[df['Biden']==1][['Timestamp', 'polarity']]
biden = biden.sort_values(by='Timestamp', ascending=True)
biden['MA Polarity'] = biden.polarity.rolling(10, min_periods=3).mean()

trump = df[df['Trump']==1][['Timestamp', 'polarity']]
trump = trump.sort_values(by='Timestamp', ascending=True)
trump['MA Polarity'] = trump.polarity.rolling(10, min_periods=3).mean()

# --- Nouvelle Cellule ---

trump.head()

# --- Nouvelle Cellule ---

repub = 'red'
demo = 'blue'
fig, axes = plt.subplots(2, 1, figsize=(13, 10))

axes[0].plot(biden['Timestamp'], biden['MA Polarity'])
axes[0].set_title("\n".join(["Biden Polarity"]))
axes[1].plot(trump['Timestamp'], trump['MA Polarity'], color='red')
axes[1].set_title("\n".join(["Trump Polarity"]))

fig.suptitle("\n".join(["Presidential Debate Analysis"]), y=0.98)

plt.show()

# --- Nouvelle Cellule ---

</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>Debate Analysis 1.ipynb</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour double_check.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">double_check.py</h2>
                    <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">import os
import sys
import hashlib
from collections import defaultdict

def calculate_hash(filepath, block_size=65536):
    """Calcule le hash SHA-256 d'un fichier."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while True:
                data = f.read(block_size)
                if not data:
                    break
                sha256.update(data)
        return sha256.hexdigest()
    except IOError:
        # Les erreurs de lecture sont ignorées, le fichier ne sera pas inclus
        return None

def find_duplicates(folder):
    """
    Trouve les fichiers en double en scannant le dossier fourni.
    Retourne un dictionnaire de hashs pointant vers des listes de fichiers dupliqués.
    """
    print(f"\n1. Calcul des empreintes des fichiers dans : {folder}")
    hashes = defaultdict(list)
    total_files = 0
    scanned_files = 0

    # Compter les fichiers d'abord pour la barre de progression
    for dirpath, _, filenames in os.walk(folder):
        total_files += len(filenames)

    # Scanner et hasher les fichiers
    for dirpath, _, filenames in os.walk(folder):
        for filename in filenames:
            scanned_files += 1
            filepath = os.path.join(dirpath, filename)
            # Ignorer les liens symboliques et les fichiers de 0 octet
            if not os.path.islink(filepath) and os.path.getsize(filepath) &gt; 0:
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes[file_hash].append(filepath)
            
            # Afficher la progression
            progress = (scanned_files / total_files) * 100
            sys.stdout.write(f"\rProgression: {progress:.1f}% ({scanned_files}/{total_files} fichiers)")
            sys.stdout.flush()

    print("\nScan terminé.\n")
    
    # Retourner seulement les hashs qui ont plus d'un fichier (les vrais doublons)
    return {hash_val: paths for hash_val, paths in hashes.items() if len(paths) &gt; 1}

def print_results(duplicates):
    """Affiche joliment les résultats."""
    if not duplicates:
        print("Bonne nouvelle ! Aucun fichier en double n'a été trouvé.")
        return

    print(f"2. {len(duplicates)} groupes de fichiers en double trouvés :\n")
    group_number = 1
    for file_paths in duplicates.values():
        print(f"--- Groupe {group_number} ---")
        # On trie pour avoir un ordre prévisible
        file_paths.sort()
        for i, path in enumerate(file_paths):
            if i == 0:
                print(f"  [ORIGINAL] {path}")
            else:
                print(f"  [DOUBLON]  {path}")
        print("-" * (len(str(group_number)) + 11))
        print() # Ligne vide pour la lisibilité
        group_number += 1

def delete_duplicates(duplicates):
    """Propose de supprimer les fichiers en double."""
    if not duplicates:
        return

    print("3. Action de suppression")
    print("------------------------")
    print("Pour chaque groupe, le fichier marqué [ORIGINAL] sera conservé.")
    print("Tous les fichiers marqués [DOUBLON] seront supprimés.")
    
    # Demander confirmation
    try:
        choice = input("Voulez-vous procéder à la suppression ? (o/n) : ").lower()
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return

    if choice == 'o':
        files_to_delete = []
        for file_paths in duplicates.values():
            # Garder le premier fichier (l'original), supprimer les autres
            files_to_delete.extend(file_paths[1:])
        
        if not files_to_delete:
            print("Aucun fichier à supprimer.")
            return

        print(f"\n{len(files_to_delete)} fichier(s) doublon(s) seront supprimé(s).")
        try:
            final_confirmation = input("Êtes-vous absolument sûr(e) ? Cette action est IRRÉVERSIBLE. (o/n) : ").lower()
        except (EOFError, KeyboardInterrupt):
            print("\nOpération annulée.")
            return

        if final_confirmation == 'o':
            deleted_count = 0
            for f in files_to_delete:
                try:
                    os.remove(f)
                    print(f"Supprimé : {f}")
                    deleted_count += 1
                except OSError as e:
                    print(f"ERREUR lors de la suppression de {f}: {e}")
            print(f"\nOpération terminée. {deleted_count} fichier(s) supprimé(s).")
        else:
            print("Suppression annulée.")
    else:
        print("Aucun fichier n'a été supprimé.")


if __name__ == "__main__":
    # Demander le chemin du dossier à l'utilisateur
    try:
        folder_path = input("Veuillez glisser-déposer le dossier à analyser ici, puis appuyez sur Entrée : ").strip()
        
        # Sur Mac, glisser-déposer peut ajouter des barres obliques inverses pour les espaces.
        folder_path = folder_path.replace('\\ ', ' ').strip()
        # Enlever les guillemets si présents
        if folder_path.startswith("'") and folder_path.endswith("'"):
            folder_path = folder_path[1:-1]
        if folder_path.startswith('"') and folder_path.endswith('"'):
            folder_path = folder_path[1:-1]

        if not os.path.isdir(folder_path):
            print("\nErreur : Le chemin fourni n'est pas un dossier valide.")
            sys.exit(1)

        duplicates_found = find_duplicates(folder_path)
        print_results(duplicates_found)
        delete_duplicates(duplicates_found)

    except (EOFError, KeyboardInterrupt):
        print("\nProgramme interrompu par l'utilisateur.")
        sys.exit(0)
    except Exception as e:
        print(f"\nUne erreur inattendue est survenue : {e}")
        sys.exit(1)

</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>double_check.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour double_checkv2 1.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">double_checkv2 1.py</h2>
                    <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">import os
import sys
import hashlib
import time
import json
from collections import defaultdict

# --- Fonctions de base (trouver les doublons) ---

def calculate_hash(filepath, block_size=65536):
    """Calcule le hash SHA-256 d'un fichier."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while True:
                data = f.read(block_size)
                if not data:
                    break
                sha256.update(data)
        return sha256.hexdigest()
    except IOError:
        return None

def find_duplicates(folder):
    """Trouve les fichiers en double et retourne un dictionnaire de doublons."""
    print(f"\nÉtape 1: Recherche des doublons dans : {folder}")
    hashes = defaultdict(list)
    total_files = sum(len(files) for _, _, files in os.walk(folder))
    scanned_files = 0

    for dirpath, _, filenames in os.walk(folder):
        for filename in filenames:
            scanned_files += 1
            filepath = os.path.join(dirpath, filename)
            if not os.path.islink(filepath) and os.path.getsize(filepath) &gt; 0:
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes[file_hash].append(filepath)
            
            progress = (scanned_files / total_files) * 100 if total_files &gt; 0 else 0
            sys.stdout.write(f"\rProgression: {progress:.1f}% ({scanned_files}/{total_files} fichiers)")
            sys.stdout.flush()

    print("\nRecherche des doublons terminée.\n")
    return {h: p for h, p in hashes.items() if len(p) &gt; 1}

# --- NOUVEAUTÉ : Fonctions de renommage intelligent ---

def get_readability_score(filename):
    """Attribue un score à un nom de fichier pour déterminer s'il est lisible."""
    score = len(filename)  # Les noms plus longs sont souvent meilleurs
    # Bonus pour les lettres, malus pour les noms uniquement numériques
    if any(c.isalpha() for c in filename):
        score += 20
    if filename.split('.')[0].isdigit():
        score -= 10
    return score

def get_best_filename(filepaths):
    """Choisit le meilleur nom de fichier parmi une liste de doublons."""
    best_score = -1
    best_name = ""
    for path in filepaths:
        filename = os.path.basename(path)
        score = get_readability_score(filename)
        if score &gt; best_score:
            best_score = score
            best_name = filename
    return best_name

def process_and_delete_duplicates(duplicates):
    """Gère le renommage intelligent et la suppression des doublons."""
    if not duplicates:
        print("Bonne nouvelle ! Aucun fichier en double n'a été trouvé.")
        return []

    print(f"Étape 2: Traitement de {len(duplicates)} groupes de doublons (renommage et suppression)")
    
    try:
        choice = input("Voulez-vous renommer intelligemment et supprimer les doublons ? (o/n) : ").lower()
        if choice != 'o':
            print("Opération annulée.")
            # Retourne une liste de tous les fichiers pour un éventuel classement
            all_files = set()
            for paths in duplicates.values():
                all_files.update(paths)
            return list(all_files)
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return []

    files_kept = []
    for group_paths in duplicates.values():
        group_paths.sort()  # Ordre prévisible
        original_path = group_paths[0]
        original_dir = os.path.dirname(original_path)
        
        # Renommage intelligent
        best_name = get_best_filename(group_paths)
        final_path = os.path.join(original_dir, best_name)

        if original_path != final_path:
            try:
                # S'assure que la cible n'existe pas déjà (cas rare)
                if os.path.exists(final_path):
                    print(f"  - AVERTISSEMENT: Le nom de destination '{best_name}' existe déjà. Le renommage est ignoré pour ce groupe.")
                    final_path = original_path # On annule le renommage pour ce cas
                else:
                    os.rename(original_path, final_path)
                    print(f"  - Renommé : '{os.path.basename(original_path)}' -&gt; '{best_name}'")
            except OSError as e:
                print(f"  - ERREUR de renommage : {e}. Le nom original sera conservé.")
                final_path = original_path

        files_kept.append(final_path)

        # Suppression des autres doublons
        for path_to_delete in group_paths:
            if path_to_delete != original_path:
                try:
                    os.remove(path_to_delete)
                    # print(f"  - Supprimé : {path_to_delete}")
                except OSError as e:
                    print(f"  - ERREUR de suppression de {path_to_delete}: {e}")
    
    print("\nNettoyage des doublons terminé.")
    return files_kept


# --- NOUVEAUTÉ : Fonctions de classement par IA ---

async def classify_file(filepath, categories):
    """Utilise une IA pour deviner la catégorie d'un fichier."""
    try:
        filename = os.path.basename(filepath)
        prompt = f"Analyse ce nom de fichier '{filename}' et classe-le dans l'une de ces catégories : {categories}. Réponds uniquement avec le nom de la catégorie. Si incertain, réponds 'Autre'."
        
        chatHistory = [{"role": "user", "parts": [{"text": prompt}]}]
        payload = {"contents": chatHistory}
        apiKey = "" # Aucune clé nécessaire pour ce modèle dans cet environnement
        apiUrl = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={apiKey}"
        
        response = await __fetch__(apiUrl, {
            'method': 'POST',
            'headers': {'Content-Type': 'application/json'},
            'body': json.dumps(payload)
        })
        
        result = await response.json()
        
        if result.get('candidates'):
            return result['candidates'][0]['content']['parts'][0]['text'].strip()
        else:
            return "Autre"
            
    except Exception as e:
        # print(f"Erreur API pour {filepath}: {e}")
        return "Autre"

async def classify_and_move_files(base_folder, all_files):
    """Classe tous les fichiers restants et les déplace dans des sous-dossiers thématiques."""
    print("\nÉtape 3: Classement thématique des fichiers restants par IA")
    try:
        choice = input("Voulez-vous lancer le classement automatique ? (Cela peut prendre du temps) (o/n) : ").lower()
        if choice != 'o':
            print("Classement ignoré. Le programme est terminé.")
            return
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return

    # Catégories personnalisables
    categories = ["Factures", "Recherche", "Contrats", "Photos", "Personnel", "Travail", "Admin", "Projets", "Autre"]
    
    # Crée un dossier "Fichiers Classés" pour ne pas mélanger
    classified_folder = os.path.join(base_folder, "Fichiers Classés")
    os.makedirs(classified_folder, exist_ok=True)
    
    print(f"Les fichiers seront classés dans : {classified_folder}")
    print("Catégories utilisées :", ", ".join(categories))
    
    total_files_to_classify = len(all_files)
    for i, filepath in enumerate(all_files):
        if not os.path.exists(filepath):
            continue

        progress = ((i + 1) / total_files_to_classify) * 100
        sys.stdout.write(f"\rClassement: {progress:.1f}% ({i+1}/{total_files_to_classify}) - {os.path.basename(filepath)}")
        sys.stdout.flush()

        category = await classify_file(filepath, categories)
        
        # Crée le dossier de la catégorie s'il n'existe pas
        target_dir = os.path.join(classified_folder, category)
        os.makedirs(target_dir, exist_ok=True)
        
        # Déplace le fichier
        try:
            target_path = os.path.join(target_dir, os.path.basename(filepath))
            # Gère le cas où un fichier du même nom existe déjà dans la destination
            if os.path.exists(target_path):
                base, ext = os.path.splitext(os.path.basename(filepath))
                target_path = os.path.join(target_dir, f"{base}_{int(time.time())}{ext}")
            
            os.rename(filepath, target_path)
        except OSError as e:
            print(f"\nErreur lors du déplacement de {filepath} : {e}")
            
    print("\nClassement thématique terminé !")


# --- Fonction principale ---

async def main():
    try:
        folder_path = input("Veuillez glisser-déposer le dossier à analyser ici, puis appuyez sur Entrée : ").strip()
        folder_path = folder_path.replace('\\ ', ' ').strip().strip("'\"")

        if not os.path.isdir(folder_path):
            print("\nErreur : Le chemin fourni n'est pas un dossier valide.")
            return

        duplicates_found = find_duplicates(folder_path)
        files_to_classify = process_and_delete_duplicates(duplicates_found)

        # Ajouter les fichiers non-dupliqués à la liste pour le classement
        all_files_in_folder = set()
        for dirpath, _, filenames in os.walk(folder_path):
             # On ne scanne que le dossier de base après le nettoyage, pas les nouveaux sous-dossiers
            if "Fichiers Classés" in dirpath:
                continue
            for f in filenames:
                all_files_in_folder.add(os.path.join(dirpath, f))
        
        # Combine les fichiers uniques et ceux gardés après dé-duplication
        final_list_of_files = list(set(files_to_classify) | all_files_in_folder)
        final_list_of_files = [f for f in final_list_of_files if os.path.exists(f)]


        if final_list_of_files:
            await classify_and_move_files(folder_path, final_list_of_files)
        else:
            print("\nAucun fichier à classer.")

    except (EOFError, KeyboardInterrupt):
        print("\nProgramme interrompu par l'utilisateur.")
    except Exception as e:
        print(f"\nUne erreur inattendue est survenue : {e}")

if __name__ == "__main__":
    import asyncio
    # Cette instruction est spécifique à l'environnement d'exécution pour permettre les appels réseau.
    from js import fetch as __fetch__ 
    asyncio.run(main())

</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>double_checkv2 1.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour double_checkv2.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">double_checkv2.py</h2>
                    <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">import os
import sys
import hashlib
import time
import json
from collections import defaultdict

# --- Fonctions de base (trouver les doublons) ---

def calculate_hash(filepath, block_size=65536):
    """Calcule le hash SHA-256 d'un fichier."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            while True:
                data = f.read(block_size)
                if not data:
                    break
                sha256.update(data)
        return sha256.hexdigest()
    except IOError:
        return None

def find_duplicates(folder):
    """Trouve les fichiers en double et retourne un dictionnaire de doublons."""
    print(f"\nÉtape 1: Recherche des doublons dans : {folder}")
    hashes = defaultdict(list)
    total_files = sum(len(files) for _, _, files in os.walk(folder))
    scanned_files = 0

    for dirpath, _, filenames in os.walk(folder):
        for filename in filenames:
            scanned_files += 1
            filepath = os.path.join(dirpath, filename)
            if not os.path.islink(filepath) and os.path.getsize(filepath) &gt; 0:
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes[file_hash].append(filepath)
            
            progress = (scanned_files / total_files) * 100 if total_files &gt; 0 else 0
            sys.stdout.write(f"\rProgression: {progress:.1f}% ({scanned_files}/{total_files} fichiers)")
            sys.stdout.flush()

    print("\nRecherche des doublons terminée.\n")
    return {h: p for h, p in hashes.items() if len(p) &gt; 1}

# --- NOUVEAUTÉ : Fonctions de renommage intelligent ---

def get_readability_score(filename):
    """Attribue un score à un nom de fichier pour déterminer s'il est lisible."""
    score = len(filename)  # Les noms plus longs sont souvent meilleurs
    # Bonus pour les lettres, malus pour les noms uniquement numériques
    if any(c.isalpha() for c in filename):
        score += 20
    if filename.split('.')[0].isdigit():
        score -= 10
    return score

def get_best_filename(filepaths):
    """Choisit le meilleur nom de fichier parmi une liste de doublons."""
    best_score = -1
    best_name = ""
    for path in filepaths:
        filename = os.path.basename(path)
        score = get_readability_score(filename)
        if score &gt; best_score:
            best_score = score
            best_name = filename
    return best_name

def process_and_delete_duplicates(duplicates):
    """Gère le renommage intelligent et la suppression des doublons."""
    if not duplicates:
        print("Bonne nouvelle ! Aucun fichier en double n'a été trouvé.")
        return []

    print(f"Étape 2: Traitement de {len(duplicates)} groupes de doublons (renommage et suppression)")
    
    try:
        choice = input("Voulez-vous renommer intelligemment et supprimer les doublons ? (o/n) : ").lower()
        if choice != 'o':
            print("Opération annulée.")
            # Retourne une liste de tous les fichiers pour un éventuel classement
            all_files = set()
            for paths in duplicates.values():
                all_files.update(paths)
            return list(all_files)
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return []

    files_kept = []
    for group_paths in duplicates.values():
        group_paths.sort()  # Ordre prévisible
        original_path = group_paths[0]
        original_dir = os.path.dirname(original_path)
        
        # Renommage intelligent
        best_name = get_best_filename(group_paths)
        final_path = os.path.join(original_dir, best_name)

        if original_path != final_path:
            try:
                # S'assure que la cible n'existe pas déjà (cas rare)
                if os.path.exists(final_path):
                    print(f"  - AVERTISSEMENT: Le nom de destination '{best_name}' existe déjà. Le renommage est ignoré pour ce groupe.")
                    final_path = original_path # On annule le renommage pour ce cas
                else:
                    os.rename(original_path, final_path)
                    print(f"  - Renommé : '{os.path.basename(original_path)}' -&gt; '{best_name}'")
            except OSError as e:
                print(f"  - ERREUR de renommage : {e}. Le nom original sera conservé.")
                final_path = original_path

        files_kept.append(final_path)

        # Suppression des autres doublons
        for path_to_delete in group_paths:
            if path_to_delete != original_path:
                try:
                    os.remove(path_to_delete)
                    # print(f"  - Supprimé : {path_to_delete}")
                except OSError as e:
                    print(f"  - ERREUR de suppression de {path_to_delete}: {e}")
    
    print("\nNettoyage des doublons terminé.")
    return files_kept


# --- NOUVEAUTÉ : Fonctions de classement par IA ---

async def classify_file(filepath, categories):
    """Utilise une IA pour deviner la catégorie d'un fichier."""
    try:
        filename = os.path.basename(filepath)
        prompt = f"Analyse ce nom de fichier '{filename}' et classe-le dans l'une de ces catégories : {categories}. Réponds uniquement avec le nom de la catégorie. Si incertain, réponds 'Autre'."
        
        chatHistory = [{"role": "user", "parts": [{"text": prompt}]}]
        payload = {"contents": chatHistory}
        apiKey = "" # Aucune clé nécessaire pour ce modèle dans cet environnement
        apiUrl = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={apiKey}"
        
        response = await __fetch__(apiUrl, {
            'method': 'POST',
            'headers': {'Content-Type': 'application/json'},
            'body': json.dumps(payload)
        })
        
        result = await response.json()
        
        if result.get('candidates'):
            return result['candidates'][0]['content']['parts'][0]['text'].strip()
        else:
            return "Autre"
            
    except Exception as e:
        # print(f"Erreur API pour {filepath}: {e}")
        return "Autre"

async def classify_and_move_files(base_folder, all_files):
    """Classe tous les fichiers restants et les déplace dans des sous-dossiers thématiques."""
    print("\nÉtape 3: Classement thématique des fichiers restants par IA")
    try:
        choice = input("Voulez-vous lancer le classement automatique ? (Cela peut prendre du temps) (o/n) : ").lower()
        if choice != 'o':
            print("Classement ignoré. Le programme est terminé.")
            return
    except (EOFError, KeyboardInterrupt):
        print("\nOpération annulée.")
        return

    # Catégories personnalisables
    categories = ["Factures", "Recherche", "Contrats", "Photos", "Personnel", "Travail", "Admin", "Projets", "Autre"]
    
    # Crée un dossier "Fichiers Classés" pour ne pas mélanger
    classified_folder = os.path.join(base_folder, "Fichiers Classés")
    os.makedirs(classified_folder, exist_ok=True)
    
    print(f"Les fichiers seront classés dans : {classified_folder}")
    print("Catégories utilisées :", ", ".join(categories))
    
    total_files_to_classify = len(all_files)
    for i, filepath in enumerate(all_files):
        if not os.path.exists(filepath):
            continue

        progress = ((i + 1) / total_files_to_classify) * 100
        sys.stdout.write(f"\rClassement: {progress:.1f}% ({i+1}/{total_files_to_classify}) - {os.path.basename(filepath)}")
        sys.stdout.flush()

        category = await classify_file(filepath, categories)
        
        # Crée le dossier de la catégorie s'il n'existe pas
        target_dir = os.path.join(classified_folder, category)
        os.makedirs(target_dir, exist_ok=True)
        
        # Déplace le fichier
        try:
            target_path = os.path.join(target_dir, os.path.basename(filepath))
            # Gère le cas où un fichier du même nom existe déjà dans la destination
            if os.path.exists(target_path):
                base, ext = os.path.splitext(os.path.basename(filepath))
                target_path = os.path.join(target_dir, f"{base}_{int(time.time())}{ext}")
            
            os.rename(filepath, target_path)
        except OSError as e:
            print(f"\nErreur lors du déplacement de {filepath} : {e}")
            
    print("\nClassement thématique terminé !")


# --- Fonction principale ---

async def main():
    try:
        folder_path = input("Veuillez glisser-déposer le dossier à analyser ici, puis appuyez sur Entrée : ").strip()
        folder_path = folder_path.replace('\\ ', ' ').strip().strip("'\"")

        if not os.path.isdir(folder_path):
            print("\nErreur : Le chemin fourni n'est pas un dossier valide.")
            return

        duplicates_found = find_duplicates(folder_path)
        files_to_classify = process_and_delete_duplicates(duplicates_found)

        # Ajouter les fichiers non-dupliqués à la liste pour le classement
        all_files_in_folder = set()
        for dirpath, _, filenames in os.walk(folder_path):
             # On ne scanne que le dossier de base après le nettoyage, pas les nouveaux sous-dossiers
            if "Fichiers Classés" in dirpath:
                continue
            for f in filenames:
                all_files_in_folder.add(os.path.join(dirpath, f))
        
        # Combine les fichiers uniques et ceux gardés après dé-duplication
        final_list_of_files = list(set(files_to_classify) | all_files_in_folder)
        final_list_of_files = [f for f in final_list_of_files if os.path.exists(f)]


        if final_list_of_files:
            await classify_and_move_files(folder_path, final_list_of_files)
        else:
            print("\nAucun fichier à classer.")

    except (EOFError, KeyboardInterrupt):
        print("\nProgramme interrompu par l'utilisateur.")
    except Exception as e:
        print(f"\nUne erreur inattendue est survenue : {e}")

if __name__ == "__main__":
    import asyncio
    # Cette instruction est spécifique à l'environnement d'exécution pour permettre les appels réseau.
    from js import fetch as __fetch__ 
    asyncio.run(main())

</code></pre>
                </div>
                <footer class="bg-gray-50 border-t border-gray-200 p-5">
                    <h3 class="font-semibold text-gray-700">Pour citer ce code :</h3>
                    <div class="mt-2 text-sm text-gray-600 bg-gray-100 p-3 rounded-md">
                        <p>Loyer, Dominique. (2024). <em>double_checkv2.py</em> [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html</p>
                    </div>
                </footer>
            </article>



            <!-- Bloc pour double.py -->
            <article class="bg-white rounded-lg shadow-lg overflow-hidden">
                <header class="p-5 bg-gray-800 text-white">
                    <h2 class="text-2xl font-semibold">double.py</h2>
                    <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                    <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
                </header>
                <div class="p-5">
                    <pre><code class="language-python">import os
import hashlib
import tkinter as tk
from tkinter import filedialog, ttk, messagebox

# --- Fonctions principales ---

def calculate_hash(filepath, block_size=65536):
    """Calcule le hash SHA-256 d'un fichier."""
    sha256 = hashlib.sha256()
    try:
        with open(filepath, 'rb') as f:
            for block in iter(lambda: f.read(block_size), b''):
                sha256.update(block)
        return sha256.hexdigest()
    except IOError as e:
        print(f"Erreur de lecture du fichier : {filepath} ({e})")
        return None

def find_duplicate_files(folder_path, progress_callback):
    """
    Trouve les fichiers en double dans un dossier et ses sous-dossiers.
    Retourne un dictionnaire où les clés sont les hashs et les valeurs sont les listes de chemins de fichiers identiques.
    """
    hashes = {}
    duplicates = {}
    file_count = 0
    scanned_count = 0

    for dirpath, _, filenames in os.walk(folder_path):
        file_count += len(filenames)

    for dirpath, _, filenames in os.walk(folder_path):
        for filename in filenames:
            filepath = os.path.join(dirpath, filename)
            if not os.path.islink(filepath):
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes.setdefault(file_hash, []).append(filepath)
            scanned_count += 1
            progress_callback(scanned_count, file_count)

    for file_hash, filepaths in hashes.items():
        if len(filepaths) &gt; 1:
            duplicates[file_hash] = filepaths
            
    return duplicates

def delete_files(files_to_delete):
    """Supprime les fichiers sélectionnés."""
    for file_path in files_to_delete:
        try:
            os.remove(file_path)
            print(f"Fichier supprimé : {file_path}")
        except OSError as e:
            print(f"Erreur lors de la suppression du fichier {file_path}: {e}")

# --- Interface graphique (GUI) ---

class DuplicateFinderApp(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Chercheur de Fichiers Doublons (v2)")
        self.geometry("800x600")
        self.configure(bg="#f0f0f0")
        self.duplicates = {}
        self.create_widgets()

    def create_widgets(self):
        top_frame = tk.Frame(self, padx=10, pady=10, bg="#f0f0f0")
        top_frame.pack(fill=tk.X)

        tk.Label(top_frame, text="Dossier à scanner :", bg="#f0f0f0").pack(side=tk.LEFT, padx=(0, 5))
        
        # MODIFICATION : Utilisation directe de l'Entry widget
        self.folder_entry = tk.Entry(top_frame, width=60)
        self.folder_entry.pack(side=tk.LEFT, expand=True, fill=tk.X)

        browse_button = ttk.Button(top_frame, text="Parcourir...", command=self.browse_folder)
        browse_button.pack(side=tk.LEFT, padx=(5, 0))

        scan_button = ttk.Button(self, text="Scanner les Fichiers", command=self.start_scan)
        scan_button.pack(pady=10)

        self.progress = ttk.Progressbar(self, orient="horizontal", length=400, mode="determinate")
        self.progress.pack(pady=5)
        self.progress_label = tk.Label(self, text="", bg="#f0f0f0")
        self.progress_label.pack()

        result_frame = tk.Frame(self, bg="white", bd=1, relief=tk.SUNKEN)
        result_frame.pack(expand=True, fill=tk.BOTH, padx=10, pady=5)
        
        self.tree = ttk.Treeview(result_frame, columns=("path",), show="headings")
        self.tree.heading("path", text="Chemin du Fichier")
        self.tree.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)
        
        scrollbar = ttk.Scrollbar(result_frame, orient="vertical", command=self.tree.yview)
        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        self.tree.configure(yscrollcommand=scrollbar.set)

        action_frame = tk.Frame(self, padx=10, pady=10, bg="#f0f0f0")
        action_frame.pack(fill=tk.X)

        delete_button = ttk.Button(action_frame, text="Supprimer la sélection (conserver le premier)", command=self.delete_selected)
        delete_button.pack(side=tk.RIGHT)

    def browse_folder(self):
        """Ouvre une boîte de dialogue pour choisir un dossier."""
        directory = filedialog.askdirectory(title="Sélectionnez un dossier")
        
        # MODIFICATION : Ligne de débogage pour voir si le chemin est capturé
        print(f"Terminal debug: Dossier sélectionné -&gt; '{directory}'")
        
        if directory:
            self.folder_entry.delete(0, tk.END)
            self.folder_entry.insert(0, directory)

    def update_progress(self, current, total):
        self.progress['value'] = (current / total) * 100
        self.progress_label['text'] = f"{current} / {total} fichiers scannés"
        self.update_idletasks()

    def start_scan(self):
        # MODIFICATION : Obtenir le chemin directement depuis l'Entry widget
        path = self.folder_entry.get()
        if not path:
            messagebox.showwarning("Avertissement", "Veuillez sélectionner un dossier avant de scanner.")
            return

        for i in self.tree.get_children():
            self.tree.delete(i)
        
        self.progress['value'] = 0
        self.progress_label['text'] = "Scan en cours..."
        self.update()

        try:
            self.duplicates = find_duplicate_files(path, self.update_progress)
            self.display_duplicates()
        except Exception as e:
            messagebox.showerror("Erreur", f"Une erreur est survenue : {e}")

    def display_duplicates(self):
        if not self.duplicates:
            messagebox.showinfo("Résultats", "Aucun fichier en double n'a été trouvé !")
            self.progress_label['text'] = "Scan terminé. Aucun doublon."
            return

        self.progress_label['text'] = f"Scan terminé. {len(self.duplicates)} groupes de doublons trouvés."
        group_count = 1
        for file_hash, filepaths in self.duplicates.items():
            group_id = self.tree.insert("", "end", values=(f"--- Groupe de doublons {group_count} ({len(filepaths)} fichiers) ---",))
            self.tree.item(group_id, tags=('group_header',))
            for i, path in enumerate(filepaths):
                tag = 'original' if i == 0 else 'duplicate'
                self.tree.insert(group_id, "end", values=(path,), tags=(tag, file_hash))
            group_count += 1
        
        self.tree.tag_configure('group_header', background='#e0e0e0', font=('Helvetica', 10, 'bold'))
        self.tree.tag_configure('original', foreground='green')
        self.tree.tag_configure('duplicate', foreground='red')

    def delete_selected(self):
        if not self.duplicates:
            messagebox.showinfo("Information", "Aucun doublon à supprimer.")
            return

        if not messagebox.askyesno("Confirmation", 
                                   "Voulez-vous vraiment supprimer tous les fichiers marqués en rouge ?\n"
                                   "Cette action est irréversible. Seul le premier fichier de chaque groupe (en vert) sera conservé."):
            return

        files_to_remove = []
        for file_hash, filepaths in self.duplicates.items():
            files_to_remove.extend(filepaths[1:])

        delete_files(files_to_remove)
        messagebox.showinfo("Opération terminée", f"{len(files_to_remove)} fichiers doublons ont été supprimés.")
        self.start_scan()


if __name__ == "__main__":
    app = DuplicateFinderApp()
    app.mainloop()

Instructions

Remplacez le code dans votre fichier doublon.py par ce nouveau code.
Lancez le script depuis le Terminal comme avant (python3 doublon.py).
Gardez un œil sur la fenêtre du Terminal en arrière-plan.
Dans l'application, cliquez sur "Parcourir...", sélectionnez un dossier et cliquez sur "Ouvrir".
Regardez immédiatement votre fenêtre Terminal.

Vous devriez voir une nouvelle ligne apparaître, qui ressemble à ceci : Terminal debug: Dossier sélectionné -> '/Users/votrenom/Documents'

Scénario 1 : Le chemin s'affiche dans le Terminal ET dans l'application C'est parfait ! Le problème est résolu. Vous pouvez maintenant lancer le scan.

Scénario 2 : Le chemin s'affiche dans le Terminal mais PAS dans l'application C'est peu probable, mais si cela arrive, c'est un bug d'affichage de Tkinter.

Scénario 3 : Le chemin NE s'affiche PAS dans le Terminal (il affiche des guillemets vides : '') C'est le cas le plus probable. Cela confirme que le problème vient des autorisations de macOS. Le système d'exploitation bloque le script et ne lui transmet pas le nom du dossier que vous avez choisi.

Si c'est le cas (Scénario 3), voici comment le résoudre : Allez dans Réglages Système > Confidentialité et sécurité > Fichiers et dossiers. Cherchez l'application Terminal dans la liste et assurez-vous qu'elle a l'autorisation d'accéder à votre dossier "Documents", "Téléchargements" ou là où se trouvent vos fichiers.

Tenez-moi au courant du résultat ! La ligne de debug dans le Terminal nous donnera la c

Pour citer ce code :

Loyer, Dominique. (2024). double.py [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html

        <!-- Bloc pour doublecheck.py -->
        <article class="bg-white rounded-lg shadow-lg overflow-hidden">
            <header class="p-5 bg-gray-800 text-white">
                <h2 class="text-2xl font-semibold">doublecheck.py</h2>
                <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
            </header>
            <div class="p-5">
                <pre><code class="language-python">import os

import hashlib import tkinter as tk from tkinter import filedialog, ttk, messagebox

--- Fonctions principales ---

def calculate_hash(filepath, block_size=65536): """Calcule le hash SHA-256 d'un fichier.""" sha256 = hashlib.sha256() try: with open(filepath, 'rb') as f: for block in iter(lambda: f.read(block_size), b''): sha256.update(block) return sha256.hexdigest() except IOError as e: print(f"Erreur de lecture du fichier : {filepath} ({e})") return None

def find_duplicate_files(folder_path, progress_callback): """ Trouve les fichiers en double dans un dossier et ses sous-dossiers. Retourne un dictionnaire où les clés sont les hashs et les valeurs sont les listes de chemins de fichiers identiques. """ hashes = {} duplicates = {} file_count = 0 scanned_count = 0

try:
    for dirpath, _, filenames in os.walk(folder_path):
        file_count += len(filenames)

    if file_count == 0:
        progress_callback(0, 0) # Gérer le cas du dossier vide
        return {}

    for dirpath, _, filenames in os.walk(folder_path):
        for filename in filenames:
            filepath = os.path.join(dirpath, filename)
            if not os.path.islink(filepath):
                file_hash = calculate_hash(filepath)
                if file_hash:
                    hashes.setdefault(file_hash, []).append(filepath)
            scanned_count += 1
            progress_callback(scanned_count, file_count)

except FileNotFoundError:
    messagebox.showerror("Erreur", f"Le dossier '{folder_path}' n'a pas été trouvé.")
    return {}
except PermissionError:
    messagebox.showerror("Erreur", f"Permission refusée pour accéder au dossier '{folder_path}'.\nVeuillez vérifier les autorisations de sécurité de macOS.")
    return {}


for file_hash, filepaths in hashes.items():
    if len(filepaths) &gt; 1:
        duplicates[file_hash] = filepaths
        
return duplicates

def delete_files(files_to_delete): """Supprime les fichiers sélectionnés.""" for file_path in files_to_delete: try: os.remove(file_path) print(f"Fichier supprimé : {file_path}") except OSError as e: print(f"Erreur lors de la suppression du fichier {file_path}: {e}")

--- Interface graphique (GUI) ---

class DuplicateFinderApp(tk.Tk): def init(self): super().init() self.title("Chercheur de Fichiers Doublons (v2 - corrigé)") self.geometry("800x600") self.configure(bg="#f0f0f0") self.duplicates = {} self.create_widgets()

def create_widgets(self):
    top_frame = tk.Frame(self, padx=10, pady=10, bg="#f0f0f0")
    top_frame.pack(fill=tk.X)

    tk.Label(top_frame, text="Dossier à scanner :", bg="#f0f0f0").pack(side=tk.LEFT, padx=(0, 5))
    
    self.folder_entry = tk.Entry(top_frame, width=60)
    self.folder_entry.pack(side=tk.LEFT, expand=True, fill=tk.X)

    browse_button = ttk.Button(top_frame, text="Parcourir...", command=self.browse_folder)
    browse_button.pack(side=tk.LEFT, padx=(5, 0))

    scan_button = ttk.Button(self, text="Scanner les Fichiers", command=self.start_scan)
    scan_button.pack(pady=10)

    self.progress = ttk.Progressbar(self, orient="horizontal", length=400, mode="determinate")
    self.progress.pack(pady=5)
    self.progress_label = tk.Label(self, text="", bg="#f0f0f0")
    self.progress_label.pack()

    result_frame = tk.Frame(self, bg="white", bd=1, relief=tk.SUNKEN)
    result_frame.pack(expand=True, fill=tk.BOTH, padx=10, pady=5)
    
    self.tree = ttk.Treeview(result_frame, columns=("path",), show="headings")
    self.tree.heading("path", text="Chemin du Fichier")
    self.tree.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)
    
    scrollbar = ttk.Scrollbar(result_frame, orient="vertical", command=self.tree.yview)
    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    self.tree.configure(yscrollcommand=scrollbar.set)

    action_frame = tk.Frame(self, padx=10, pady=10, bg="#f0f0f0")
    action_frame.pack(fill=tk.X)

    delete_button = ttk.Button(action_frame, text="Supprimer la sélection (conserver le premier)", command=self.delete_selected)
    delete_button.pack(side=tk.RIGHT)

def browse_folder(self):
    directory = filedialog.askdirectory(title="Sélectionnez un dossier")
    
    print(f"Terminal debug: Dossier sélectionné -&gt; '{directory}'")
    
    if directory:
        self.folder_entry.delete(0, tk.END)
        self.folder_entry.insert(0, directory)

def update_progress(self, current, total):
    if total &gt; 0:
        self.progress['value'] = (current / total) * 100
    else:
        self.progress['value'] = 100
    self.progress_label['text'] = f"{current} / {total} fichiers scannés"
    self.update_idletasks()

def start_scan(self):
    path = self.folder_entry.get()
    if not path:
        messagebox.showwarning("Avertissement", "Veuillez sélectionner un dossier avant de scanner.")
        return

    for i in self.tree.get_children():
        self.tree.delete(i)
    
    self.progress['value'] = 0
    self.progress_label['text'] = "Scan en cours..."
    self.update()

    try:
        self.duplicates = find_duplicate_files(path, self.update_progress)
        self.display_duplicates()
    except Exception as e:
        messagebox.showerror("Erreur", f"Une erreur est survenue pendant le scan: {e}")

def display_duplicates(self):
    if not self.duplicates:
        messagebox.showinfo("Résultats", "Aucun fichier en double n'a été trouvé !")
        self.progress_label['text'] = "Scan terminé. Aucun doublon."
        return

    self.progress_label['text'] = f"Scan terminé. {len(self.duplicates)} groupes de doublons trouvés."
    group_count = 1
    for file_hash, filepaths in self.duplicates.items():
        group_id = self.tree.insert("", "end", values=(f"--- Groupe de doublons {group_count} ({len(filepaths)} fichiers) ---",))
        self.tree.item(group_id, tags=('group_header',))
        filepaths.sort() # Trier pour avoir un ordre consistent
        for i, path in enumerate(filepaths):
            tag = 'original' if i == 0 else 'duplicate'
            self.tree.insert(group_id, "end", values=(path,), tags=(tag, file_hash))
        group_count += 1
    
    self.tree.tag_configure('group_header', background='#e0e0e0', font=('Helvetica', 10, 'bold'))
    self.tree.tag_configure('original', foreground='green')
    self.tree.tag_configure('duplicate', foreground='red')

def delete_selected(self):
    if not self.duplicates:
        messagebox.showinfo("Information", "Aucun doublon à supprimer.")
        return

    if not messagebox.askyesno("Confirmation", 
                               "Voulez-vous vraiment supprimer tous les fichiers marqués en rouge ?\n"
                               "Cette action est irréversible. Seul le premier fichier de chaque groupe (en vert) sera conservé."):
        return

    files_to_remove = []
    for file_hash, filepaths in self.duplicates.items():
        files_to_remove.extend(filepaths[1:])

    delete_files(files_to_remove)
    messagebox.showinfo("Opération terminée", f"{len(files_to_remove)} fichiers doublons ont été supprimés.")
    
    # Rafraîchir l'affichage
    self.start_scan()

if name == "main": app = DuplicateFinderApp() app.mainloop()

Pour citer ce code :

Loyer, Dominique. (2024). doublecheck.py [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html

        <!-- Bloc pour doublon.py -->
        <article class="bg-white rounded-lg shadow-lg overflow-hidden">
            <header class="p-5 bg-gray-800 text-white">
                <h2 class="text-2xl font-semibold">doublon.py</h2>
                <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
            </header>
            <div class="p-5">
                <pre><code class="language-python">import os

import hashlib import tkinter as tk from tkinter import filedialog, ttk, messagebox

--- Fonctions principales ---

def calculate_hash(filepath, block_size=65536): """Calcule le hash SHA-256 d'un fichier.""" sha256 = hashlib.sha256() try: with open(filepath, 'rb') as f: # Lire le fichier par blocs pour ne pas surcharger la mémoire for block in iter(lambda: f.read(block_size), b''): sha256.update(block) return sha256.hexdigest() except IOError as e: # Gère les erreurs si un fichier ne peut pas être lu print(f"Erreur de lecture du fichier : {filepath} ({e})") return None

def find_duplicate_files(folder_path, progress_callback): """ Trouve les fichiers en double dans un dossier et ses sous-dossiers. Retourne un dictionnaire où les clés sont les hash et les valeurs sont les listes de chemins de fichiers identiques. """ hashes = {} duplicates = {} file_count = 0 scanned_count = 0

# Première passe : compter le nombre total de fichiers
for dirpath, _, filenames in os.walk(folder_path):
    file_count += len(filenames)

# Deuxième passe : scanner les fichiers et trouver les doublons
for dirpath, _, filenames in os.walk(folder_path):
    for filename in filenames:
        filepath = os.path.join(dirpath, filename)
        
        # Ignore les liens symboliques pour éviter les erreurs
        if not os.path.islink(filepath):
            file_hash = calculate_hash(filepath)
            if file_hash:
                # Ajoute le fichier à la liste des fichiers ayant ce hash
                hashes.setdefault(file_hash, []).append(filepath)

        scanned_count += 1
        # Call the progress callback only if it's provided
        if progress_callback:
            progress_callback(scanned_count, file_count)


# Filtre pour ne garder que les hashs avec plus d'un fichier (les doublons)
for file_hash, filepaths in hashes.items():
    if len(filepaths) &gt; 1:
        duplicates[file_hash] = filepaths
        
return duplicates

def delete_files(files_to_delete): """Supprime les fichiers sélectionnés.""" for file_path in files_to_delete: try: os.remove(file_path) print(f"Fichier supprimé : {file_path}") except OSError as e: print(f"Erreur lors de la suppression du fichier {file_path}: {e}")

--- Interface graphique (GUI) ---

class DuplicateFinderApp(tk.Tk): def init(self): super().init() self.title("Chercheur de Fichiers Doublons") self.geometry("800x600") self.configure(bg="#f0f0f0")

    # --- Variables ---
    self.folder_path = tk.StringVar()
    self.duplicates = {}

    # --- Widgets ---
    self.create_widgets()

def create_widgets(self):
    # Frame pour la sélection du dossier
    top_frame = tk.Frame(self, padx=10, pady=10, bg="#f0f0f0")
    top_frame.pack(fill=tk.X)

    tk.Label(top_frame, text="Dossier à scanner :", bg="#f0f0f0").pack(side=tk.LEFT, padx=(0, 5))
    
    entry = tk.Entry(top_frame, textvariable=self.folder_path, width=60)
    entry.pack(side=tk.LEFT, expand=True, fill=tk.X)

    browse_button = ttk.Button(top_frame, text="Parcourir...", command=self.browse_folder)
    browse_button.pack(side=tk.LEFT, padx=(5, 0))

    # Bouton pour démarrer le scan
    scan_button = ttk.Button(self, text="Scanner les Fichiers", command=self.start_scan)
    scan_button.pack(pady=10)

    # Barre de progression
    self.progress = ttk.Progressbar(self, orient="horizontal", length=400, mode="determinate")
    self.progress.pack(pady=5)
    self.progress_label = tk.Label(self, text="", bg="#f0f0f0")
    self.progress_label.pack()

    # Frame pour les résultats
    result_frame = tk.Frame(self, bg="white", bd=1, relief=tk.SUNKEN)
    result_frame.pack(expand=True, fill=tk.BOTH, padx=10, pady=5)
    
    # Arbre pour afficher les résultats
    self.tree = ttk.Treeview(result_frame, columns=("path",), show="headings")
    self.tree.heading("path", text="Chemin du Fichier")
    self.tree.pack(side=tk.LEFT, expand=True, fill=tk.BOTH)
    
    # Scrollbar
    scrollbar = ttk.Scrollbar(result_frame, orient="vertical", command=self.tree.yview)
    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    self.tree.configure(yscrollcommand=scrollbar.set)

    # Frame pour les boutons d'action
    action_frame = tk.Frame(self, padx=10, pady=10, bg="#f0f0f0")
    action_frame.pack(fill=tk.X)

    delete_button = ttk.Button(action_frame, text="Supprimer la sélection (conserver le premier)", command=self.delete_selected)
    delete_button.pack(side=tk.RIGHT)

def browse_folder(self):
    """Ouvre une boîte de dialogue pour choisir un dossier."""
    directory = filedialog.askdirectory(title="Sélectionnez un dossier")
    if directory:
        self.folder_path.set(directory)

def update_progress(self, current, total):
    """Met à jour la barre de progression."""
    # Ensure self.progress exists before trying to update it
    if hasattr(self, 'progress'):
        self.progress['value'] = (current / total) * 100
        self.progress_label['text'] = f"{current} / {total} fichiers scannés"
        self.update_idletasks() # Met à jour l'interface

def start_scan(self):
    """Lance le processus de scan."""
    path = self.folder_path.get()
    if not path:
        messagebox.showwarning("Avertissement", "Veuillez sélectionner un dossier avant de scanner.")
        return

    # Nettoyer l'affichage précédent
    for i in self.tree.get_children():
        self.tree.delete(i)
    
    # Ensure self.progress exists before trying to reset it
    if hasattr(self, 'progress'):
        self.progress['value'] = 0
        self.progress_label['text'] = "Scan en cours..."
        self.update()

    try:
        # Pass the update_progress method if the GUI is running
        progress_func = self.update_progress if hasattr(self, 'progress') else None
        self.duplicates = find_duplicate_files(path, progress_func)
        self.display_duplicates()
    except Exception as e:
        messagebox.showerror("Erreur", f"Une erreur est survenue : {e}")


def display_duplicates(self):
    """Affiche les doublons trouvés dans l'arbre."""
    # Only attempt to display if the GUI is running
    if not hasattr(self, 'tree'):
         if self.duplicates:
             print("Doublons trouvés (GUI non affichée):")
             for file_hash, filepaths in self.duplicates.items():
                 print(f"  Hash: {file_hash}")
                 for path in filepaths:
                     print(f"    - {path}")
         else:
             print("Aucun fichier en double n'a été trouvé.")
         return


    if not self.duplicates:
        messagebox.showinfo("Résultats", "Aucun fichier en double n'a été trouvé !")
        self.progress_label['text'] = "Scan terminé. Aucun doublon."
        return

    self.progress_label['text'] = f"Scan terminé. {len(self.duplicates)} groupes de doublons trouvés."

    group_count = 1
    for file_hash, filepaths in self.duplicates.items():
        # Ajoute un en-tête pour chaque groupe de doublons
        group_id = self.tree.insert("", "end", text="", values=(f"--- Groupe de doublons {group_count} ({len(filepaths)} fichiers) ---",))
        self.tree.item(group_id, tags=('group_header',))

        for i, path in enumerate(filepaths):
            # Le premier fichier est marqué comme "original"
            tag = 'original' if i == 0 else 'duplicate'
            self.tree.insert(group_id, "end", values=(path,), tags=(tag, file_hash))
        
        group_count += 1
    
    # Appliquer des couleurs pour une meilleure lisibilité
    self.tree.tag_configure('group_header', background='#e0e0e0', font=('Helvetica', 10, 'bold'))
    self.tree.tag_configure('original', foreground='green')
    self.tree.tag_configure('duplicate', foreground='red')


def delete_selected(self):
    """Supprime les doublons en gardant le premier de chaque groupe."""
     # Only attempt to delete if the GUI is running
    if not hasattr(self, 'tree'):
         print("Suppression via GUI non possible, GUI non affichée.")
         return


    if not self.duplicates:
        messagebox.showinfo("Information", "Aucun doublon à supprimer.")
        return

    if not messagebox.askyesno("Confirmation", 
                               "Voulez-vous vraiment supprimer tous les fichiers marqués en rouge ?\n"
                               "Cette action est irréversible. Seul le premier fichier de chaque groupe (en vert) sera conservé."):
        return

    files_to_remove = []
    for file_hash, filepaths in self.duplicates.items():
        # On ajoute tous les fichiers sauf le premier à la liste de suppression
        files_to_remove.extend(filepaths[1:])

    delete_files(files_to_remove)
    
    messagebox.showinfo("Opération terminée", f"{len(files_to_remove)} fichiers doublons ont été supprimés.")
    
    # Rafraîchir l'affichage
    self.start_scan()

if name == "main": # Check if a display is available before trying to start the GUI if 'DISPLAY' in os.environ: print("GUI environment detected, starting application...") app = DuplicateFinderApp() app.mainloop() else: print("No display environment detected. Running in headless mode.") print("To use the GUI, please run this code in an environment with a graphical display or set up X11 forwarding.") # You could add command-line based functionality here if needed # For example, scan a folder specified as an argument and print duplicates # For this example, we'll just exit gracefully

Pour citer ce code :

Loyer, Dominique. (2024). doublon.py [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html

        <!-- Bloc pour doublons_mem_13juin.py -->
        <article class="bg-white rounded-lg shadow-lg overflow-hidden">
            <header class="p-5 bg-gray-800 text-white">
                <h2 class="text-2xl font-semibold">doublons_mem_13juin.py</h2>
                <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
            </header>
            <div class="p-5">
                <pre><code class="language-python">import os

import sys import hashlib import shutil import json import requests from collections import defaultdict import time

--- NOUVEAU: Configuration de la Mémoire ---

MEMORY_FILE = os.path.join(os.path.expanduser('~'), 'Desktop', 'organizer_memory.json')

=============================================================================

--- FONCTIONS DE GESTION DE LA MÉMOIRE ---

=============================================================================

def load_memory(): """Charge la mémoire depuis le fichier JSON.""" if os.path.exists(MEMORY_FILE): print("\nINFO: Fichier de mémoire trouvé. Chargement des connaissances antérieures...") with open(MEMORY_FILE, 'r', encoding='utf-8') as f: try: return json.load(f) except json.JSONDecodeError: return {"learned_categories": [], "classification_map": {}} # Fichier corrompu print("\nINFO: Aucun fichier de mémoire trouvé. Démarrage avec une table rase.") return {"learned_categories": [], "classification_map": {}}

def save_memory(data): """Sauvegarde la mémoire dans le fichier JSON.""" print("\nMise à jour de la mémoire avec les nouvelles connaissances...") try: with open(MEMORY_FILE, 'w', encoding='utf-8') as f: json.dump(data, f, indent=4, ensure_ascii=False) print(f"Mémoire sauvegardée avec succès dans : {MEMORY_FILE}") except Exception as e: print(f"[ERREUR] Impossible de sauvegarder la mémoire : {e}")

=============================================================================

--- ÉTAPES 1 & 2 (DOUBLONS) ---

Le code reste identique aux versions précédentes.

=============================================================================

def calculate_hash(filepath, block_size=65536): sha256 = hashlib.sha256() try: with open(filepath, 'rb') as f: while True: data = f.read(block_size) if not data: break sha256.update(data) return sha256.hexdigest() except (IOError, FileNotFoundError): return None

def find_duplicates(folder): print(f"\n--- ÉTAPE 1: Recherche des doublons dans : {folder} ---") hashes = defaultdict(list) excluded_dirs = ["Doublons", "Classement_Final"] files_to_scan = [os.path.join(dp, fn) for dp, dn, fns in os.walk(folder) for fn in fns if not any(excluded in dp for excluded in excluded_dirs)] total_files = len(files_to_scan) if total_files == 0: return {}, [] for i, filepath in enumerate(files_to_scan): try: sys.stdout.write(f"\rAnalyse des fichiers : {((i + 1) / total_files) * 100:.1f}%") sys.stdout.flush() if not os.path.islink(filepath) and os.path.getsize(filepath) > 0: file_hash = calculate_hash(filepath) if file_hash: hashes[file_hash].append(filepath) except (FileNotFoundError, OSError): continue print("\nAnalyse des doublons terminée.") duplicates = {h: p for h, p in hashes.items() if len(p) > 1} unique_files = [p[0] for h, p in hashes.items() if len(p) == 1] return duplicates, unique_files

def get_readability_score(filename): score = len(filename) if any(c.isalpha() for c in filename): score += 20 if filename.split('.')[0].isdigit(): score -= 10 return score

def process_duplicates_safely(duplicates, base_folder, desktop_path): if not duplicates: print("\n--- ÉTAPE 2: Traitement des doublons ---\nBonne nouvelle ! Aucun fichier en double à traiter.") return [] print(f"\n--- ÉTAPE 2: Traitement automatique et protégé de {len(duplicates)} groupes de doublons ---") duplicates_folder = os.path.join(base_folder, "Doublons") os.makedirs(duplicates_folder, exist_ok=True) print(f"Les doublons non-protégés seront déplacés dans : {duplicates_folder}") files_kept = [] for group_paths in duplicates.values(): try: if desktop_path and any(p.startswith(desktop_path) for p in group_paths): file_to_keep = max((p for p in group_paths if p.startswith(desktop_path)), key=os.path.getmtime) final_path = file_to_keep else: file_to_keep = max(group_paths, key=os.path.getmtime) best_name = os.path.basename(max(group_paths, key=lambda p: get_readability_score(os.path.basename(p)))) original_dir = os.path.dirname(file_to_keep) potential_new_path = os.path.join(original_dir, best_name) final_path = file_to_keep if file_to_keep != potential_new_path and not os.path.exists(potential_new_path): os.rename(file_to_keep, potential_new_path) final_path = potential_new_path files_kept.append(final_path) for path in group_paths: if path != file_to_keep and not (desktop_path and path.startswith(desktop_path)): try: shutil.move(path, os.path.join(duplicates_folder, os.path.basename(path))) except Exception as e: print(f"Erreur déplacement doublon {os.path.basename(path)}: {e}") except Exception as e: print(f"\nErreur traitement groupe doublons : {e}") print("\nTraitement des doublons terminé.") return files_kept

=============================================================================

--- ÉTAPE 3: CLASSIFICATION IA (MODIFIÉE POUR UTILISER LA MÉMOIRE) ---

=============================================================================

def learn_structure_from_path(path_to_learn): learned_categories = set() if not os.path.isdir(path_to_learn): return learned_categories print(f"Analyse de la structure de : {path_to_learn}...") for root, dirs, _ in os.walk(path_to_learn): for dir_name in dirs: if dir_name.startswith('.') or dir_name.lower() in ["attachments", "files", "images"]: continue clean_name = dir_name.replace('_', ' ').strip() if len(clean_name) > 3: learned_categories.add(clean_name) return learned_categories

def propose_categories_with_ai(files_for_ai, learned_categories, api_key): """Propose des catégories pour les nouveaux fichiers, par lots et avec nouvelles tentatives.""" if not files_for_ai: return {}

print(f"\n--- ÉTAPE 3b: Interrogation de l'IA pour {len(files_for_ai)} nouveaux fichiers ---")
BATCH_SIZE = 75
MAX_RETRIES = 3
BACKOFF_FACTOR = 2

ai_classifications = {}
total_files = len(files_for_ai)

for i in range(0, total_files, BATCH_SIZE):
    # ... (Le code de batching reste le même que v13)
    batch_files = files_for_ai[i:i + BATCH_SIZE]
    batch_filenames = [os.path.basename(f) for f in batch_files]
    current_batch_num = (i // BATCH_SIZE) + 1
    total_batches = (total_files + BATCH_SIZE - 1) // BATCH_SIZE
    print(f"\nTraitement du lot {current_batch_num}/{total_batches}...")
    prompt = (f"En te basant sur cette liste de catégories apprises : {list(learned_categories)}. Pour la liste de noms de fichiers suivante : {json.dumps(batch_filenames)}. Propose la catégorie la plus pertinente pour CHAQUE fichier. Si aucune catégorie ne correspond, invente une catégorie pertinente et concise (2-4 mots). Réponds UNIQUEMENT avec un objet JSON où chaque clé est un nom de fichier et sa valeur est la catégorie proposée.")
    payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
    apiUrl = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={api_key}"
    for attempt in range(MAX_RETRIES):
        try:
            response = requests.post(apiUrl, json=payload, timeout=90)
            response.raise_for_status()
            json_text = response.json()['candidates'][0]['content']['parts'][0]['text']
            json_text = json_text.strip().replace("```json", "").replace("```", "")
            batch_classifications = json.loads(json_text)
            ai_classifications.update(batch_classifications)
            print(f"Lot {current_batch_num} traité avec succès.")
            break
        except requests.exceptions.HTTPError as err:
            if err.response.status_code in [500, 503, 504] and (attempt + 1) &lt; MAX_RETRIES:
                wait_time = BACKOFF_FACTOR * (2 ** attempt)
                print(f"  -&gt; Échec temporaire (tentative {attempt + 1}/{MAX_RETRIES}): {err.response.status_code}. Nouvelle tentative dans {wait_time}s...")
                time.sleep(wait_time)
            else:
                print(f"\n[ERREUR HTTP] Échec final du lot {current_batch_num}. Ce lot sera ignoré.")
                break
        except Exception as e:
            print(f"\n[ERREUR] Échec du lot {current_batch_num} : {e}. Ce lot sera ignoré.")
            break
    time.sleep(1)
    
return ai_classifications

=============================================================================

--- ÉTAPES 4 & 5 (VALIDATION, ORGANISATION) ---

Le code reste identique.

=============================================================================

def validate_categories(classification_plan): if not classification_plan: return set() proposed_categories = sorted(list(set(classification_plan.values()))) print("\n--- ÉTAPE 4: Validation des catégories proposées ---") for i, cat_name in enumerate(proposed_categories): print(f" {i+1}) {cat_name}") validated_categories = set() while True: try: choices_str = input("\nEntrez les numéros des catégories à conserver (ex: 1,3,4), ou 'toutes' : ") if choices_str.lower() == 'toutes': return set(proposed_categories) chosen_indices = [int(i.strip()) - 1 for i in choices_str.split(',')] for index in chosen_indices: if 0 <= index < len(proposed_categories): validated_categories.add(proposed_categories[index]) if validated_categories: print("\nCatégories validées :", ", ".join(validated_categories)) return validated_categories except ValueError: print("[ERREUR] Entrée invalide.")

def execute_final_organization(base_folder, classification_plan, validated_categories, desktop_path): print("\n--- ÉTAPE 5: Organisation finale des fichiers ---") output_root = os.path.join(base_folder, "Classement_Final") os.makedirs(output_root, exist_ok=True) print(f"Les fichiers seront déplacés et organisés dans : {output_root}") for cat in validated_categories: os.makedirs(os.path.join(output_root, cat), exist_ok=True) unclassified_dir = os.path.join(output_root, "Non Classé") os.makedirs(unclassified_dir, exist_ok=True) for i, (original_path, category) in enumerate(classification_plan.items()): sys.stdout.write(f"\rDéplacement des fichiers : {((i + 1) / len(classification_plan)) * 100:.1f}%") sys.stdout.flush() if os.path.exists(original_path) and not (desktop_path and original_path.startswith(desktop_path)): target_dir = os.path.join(output_root, category) if category in validated_categories else unclassified_dir try: shutil.move(original_path, os.path.join(target_dir, os.path.basename(original_path))) except Exception as e: print(f"\n[ERREUR] Impossible de déplacer {original_path}. Erreur: {e}") print(f"\n\nL'organisation finale est terminée !\nNote : les fichiers sur votre Bureau n'ont pas été déplacés.")

=============================================================================

--- FONCTION PRINCIPALE (main) ---

=============================================================================

def main(): try: print("--- Assistant d'Organisation v14 (avec Mémoire) ---") memory = load_memory()

    home = os.path.expanduser('~')
    desktop_path = next((p for p in [os.path.join(home, 'Desktop'), os.path.join(home, 'Bureau')] if os.path.isdir(p)), "")
    if desktop_path: print(f"Règle de protection activée pour le Bureau : {desktop_path}")
    
    api_key = input("Veuillez coller votre clé API Google AI Studio : ").strip()
    
    # --- Apprentissage ---
    obsidian_path = input("1. (Optionnel) Glissez-déposez votre coffre Obsidian pour mettre à jour la mémoire : ").strip("'\"")
    notion_path = input("2. (Optionnel) Glissez-déposez votre export Notion pour mettre à jour la mémoire : ").strip("'\"")
    
    learned_from_folders = learn_structure_from_path(obsidian_path)
    learned_from_folders.update(learn_structure_from_path(notion_path))
    
    # Met à jour les catégories de la mémoire avec les nouvelles apprises
    all_learned_categories = set(memory["learned_categories"]) | learned_from_folders
    if all_learned_categories: print(f"\nConnaissances actuelles : {len(all_learned_categories)} catégories mémorisées.")

    # --- Analyse ---
    folder_path = input("\n3. Maintenant, glissez-déposez le dossier principal à analyser : ").strip("'\"")
    if not os.path.isdir(folder_path): return

    duplicates, unique_files = find_duplicates(folder_path)
    files_kept_after_dedup = process_duplicates_safely(duplicates, folder_path, desktop_path)
    all_files_to_classify = list(set(unique_files + files_kept_after_dedup))
    all_files_to_classify = [f for f in all_files_to_classify if os.path.exists(f)]

    if not all_files_to_classify:
        print("\nIl ne reste aucun fichier à classer. Opération terminée.")
        return

    # --- Classification avec mémoire ---
    print("\n--- ÉTAPE 3a: Consultation de la mémoire pour la classification ---")
    classification_plan = {}
    files_for_ai = []
    classification_map_from_memory = memory["classification_map"]
    for f_path in all_files_to_classify:
        f_name = os.path.basename(f_path)
        if f_name in classification_map_from_memory:
            classification_plan[f_path] = classification_map_from_memory[f_name]
        else:
            files_for_ai.append(f_path)
    print(f"{len(classification_plan)} fichiers classés instantanément grâce à la mémoire.")

    if api_key and files_for_ai:
        ai_results_by_name = propose_categories_with_ai(files_for_ai, all_learned_categories, api_key)
        for f_path in files_for_ai:
            f_name = os.path.basename(f_path)
            classification_plan[f_path] = ai_results_by_name.get(f_name, "Non Classé")
    else:
         for f_path in files_for_ai:
            classification_plan[f_path] = "Non Classé"

    # --- Validation et Exécution ---
    validated_categories = validate_categories(classification_plan)
    if not validated_categories:
        print("\nAucune catégorie validée. Opération annulée.")
        return

    confirm = input("\nPrêt à lancer l'organisation finale ? (o/n) &gt; ").lower()
    if confirm == 'o':
        execute_final_organization(folder_path, classification_plan, validated_categories, desktop_path)
        
        # --- Mise à jour finale de la mémoire ---
        memory["learned_categories"] = sorted(list(validated_categories | all_learned_categories))
        for f_path, category in classification_plan.items():
            if category in validated_categories:
                memory["classification_map"][os.path.basename(f_path)] = category
        save_memory(memory)
    else:
        print("\nOpération finale annulée. La mémoire n'a pas été mise à jour.")

except (EOFError, KeyboardInterrupt):
    print("\n\nProgramme interrompu par l'utilisateur.")
except Exception as e:
    print(f"\nUne erreur inattendue est survenue : {e}")
    import traceback
    traceback.print_exc()

if name == "main": main()

Pour citer ce code :

Loyer, Dominique. (2024). doublons_mem_13juin.py [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html

        <!-- Bloc pour en-fr_13juin25.ipynb -->
        <article class="bg-white rounded-lg shadow-lg overflow-hidden">
            <header class="p-5 bg-gray-800 text-white">
                <h2 class="text-2xl font-semibold">en-fr_13juin25.ipynb</h2>
                <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
            </header>
            <div class="p-5">
                <pre><code class="language-python">from google.colab import userdata

userdata.get('HF_TOKEN')

--- Nouvelle Cellule ---

'Mettre le tokken ici de Hugging Face'

--- Nouvelle Cellule ---

Auth sur Hug‐Face si HF_TOKEN est défini dans Kaggle Secrets

try: hf_token = UserSecretsClient().get_secret("HF_TOKEN") HfFolder.save_token(hf_token) except: pass

Configuration

MODEL = "Helsinki-NLP/opus-mt-fr-en" SRC, TGT = "fr", "en" BATCH = 32 EPOCHS = 3 OUTPUT = "opus-mt-fr-en-colab"

Chargement et split du dataset

ds = load_dataset("opus_books", "en-fr") s = ds["train"].train_test_split(0.05, seed=42) s2 = s["train"].train_test_split(0.05, seed=42) raw = DatasetDict({"train": s2["train"], "validation": s2["test"], "test": s["test"]})

Tokenizer

tok = AutoTokenizer.from_pretrained(MODEL) def preprocess(ex): srcs = [t[SRC] for t in ex["translation"]] tgts = [t[TGT] for t in ex["translation"]] mi = tok(srcs, max_length=128, truncation=True, padding=False) lb = tok(text_target=tgts, max_length=128, truncation=True, padding=False) mi["labels"] = lb["input_ids"] return mi

tokenized = raw.map(preprocess, batched=True, remove_columns=raw["train"].column_names)

Modèle + DataCollator + Métriques

device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = AutoModelForSeq2SeqLM.from_pretrained(MODEL).to(device) dc = DataCollatorForSeq2Seq(tok, model=model) sacrebleu = evaluate.load("sacrebleu")

def compute_metrics(p): preds, labels = p.predictions, p.label_ids if isinstance(preds, tuple): preds = preds[0] preds = np.where(preds != -100, preds, tok.pad_token_id) labels = np.where(labels != -100, labels, tok.pad_token_id) dp = tok.batch_decode(preds, skip_special_tokens=True) dl = tok.batch_decode(labels, skip_special_tokens=True) return {"bleu": sacrebleu.compute(predictions=dp, references=[[l] for l in dl])["score"]}

args = Seq2SeqTrainingArguments( output_dir=OUTPUT, evaluation_strategy="epoch", save_strategy="epoch", per_device_train_batch_size=BATCH, per_device_eval_batch_size=BATCH, learning_rate=5e-5, num_train_epochs=EPOCHS, predict_with_generate=True, fp16=torch.cuda.is_available(), load_best_model_at_end=True, metric_for_best_model="bleu", push_to_hub=hf_token is not None, hub_model_id="USERNAME/" + OUTPUT # remplace USERNAME par ton nom )

trainer = Seq2SeqTrainer( model=model, args=args, train_dataset=tokenized["train"], eval_dataset=tokenized["validation"], tokenizer=tok, data_collator=dc, compute_metrics=compute_metrics )

Lancement

trainer.train() trainer.save_model() print(trainer.predict(tokenized["test"], metric_key_prefix="test").metrics)

Inférence

for s in ["Bonjour le monde", "J'espère BLEU ~40", "Bonne traduction !"]: out = model.generate(**tok(s, return_tensors="pt", truncation=True).to(device), max_length=128, num_beams=4) print(f"{s} → {tok.decode(out[0], skip_special_tokens=True)}")

--- Nouvelle Cellule ---

!pip install --upgrade --force-reinstall datasets huggingface_hub fsspec

--- Nouvelle Cellule ---

from datasets import load_dataset, DatasetDict

--- Nouvelle Cellule ---

Pour citer ce code :

Loyer, Dominique. (2024). en-fr_13juin25.ipynb [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html

        <!-- Bloc pour export_gemini copie.py -->
        <article class="bg-white rounded-lg shadow-lg overflow-hidden">
            <header class="p-5 bg-gray-800 text-white">
                <h2 class="text-2xl font-semibold">export_gemini copie.py</h2>
                <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
            </header>
            <div class="p-5">
                <pre><code class="language-python"># -*- coding: utf-8 -*-

=============================================================================

EXPORTATEUR DE CLAVARDAGE GEMINI EN PDF (v2.9 - Installation en 2 temps)

Description :

Ce script installe ses dépendances au premier lancement, puis s'exécute

au second lancement. C'est la méthode la plus fiable pour éviter les

erreurs de 'ModuleNotFoundError' après une installation.

Auteur : Gemini

Version : 2.9

=============================================================================

import sys import subprocess import os import time import json import platform

=============================================================================

DÉPENDANCES ET INSTALLATION AUTOMATIQUE

=============================================================================

def check_and_install_packages(): """Vérifie et installe les paquets. Si une installation a lieu, le script demandera à être relancé.""" required_packages = { 'selenium': 'selenium', 'stealth': 'selenium-stealth', 'webdriver_manager': 'webdriver-manager' }

print("--- Vérification des dépendances ---")
installations_made = False
for package_import, package_name in required_packages.items():
    try:
        __import__(package_import)
        print(f"[✓] {package_name} est déjà installé.")
    except ImportError:
        print(f"[!] {package_name} est manquant. Tentative d'installation...")
        installations_made = True
        try:
            subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
            print(f"[✓] {package_name} a été installé avec succès.")
        except subprocess.CalledProcessError as e:
            print(f"[X] ERREUR : Impossible d'installer {package_name}.")
            exit()

# Si une installation a eu lieu, on quitte pour permettre au script d'être relancé
if installations_made:
    print("\n---------------------------------------------------------")
    print("  Installation terminée. Veuillez relancer le script.")
    print("---------------------------------------------------------")
    exit()
    
print("--- Toutes les dépendances sont prêtes. ---\n")

Lancer la vérification au démarrage du script

check_and_install_packages()

Les imports sont maintenant faits en toute sécurité

from selenium import webdriver from selenium.webdriver.chrome.service import Service from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from selenium.common.exceptions import TimeoutException, NoSuchElementException from webdriver_manager.chrome import ChromeDriverManager from stealth import stealth

=============================================================================

SECTION DE CONFIGURATION (ACTION REQUISE)

=============================================================================

!! IMPORTANT !!

1. FERMEZ COMPLÈTEMENT GOOGLE CHROME AVANT DE LANCER LE SCRIPT.

(Clic droit sur l'icône dans le Dock -> Quitter)

2. Le chemin de votre profil Chrome est déjà configuré.

CHROME_PROFILE_PATH = "/Users/bk280625/Library/Application Support/Google/Chrome"

3. Découverte automatique des URLs (recommandé)

AUTO_DISCOVER_URLS = True

4. (Optionnel) Liste manuelle si AUTO_DISCOVER_URLS = False

GEMINI_URLS = []

5. Dossier où sauvegarder les PDFs.

OUTPUT_DIRECTORY = "Gemini_Exports_PDF"

6. Nombre de fois où faire défiler la page pour charger l'historique.

SCROLL_ATTEMPTS = 30

=============================================================================

FONCTIONS DU SCRIPT (NE PAS MODIFIER)

=============================================================================

def setup_driver(profile_path, download_dir): """Configure le pilote Chrome avec le gestionnaire auto, le profil et le mode discret.""" options = webdriver.ChromeOptions() options.add_argument(f"user-data-dir={profile_path}") options.add_argument("--disable-blink-features=AutomationControlled") options.add_experimental_option("excludeSwitches", ["enable-automation"]) options.add_experimental_option('useAutomationExtension', False)

settings = {
    "recentDestinations": [{"id": "Save as PDF", "origin": "local", "account": ""}],
    "selectedDestinationId": "Save as PDF",
    "version": 2,
    "isHeaderFooterEnabled": False,
    "isCssBackgroundEnabled": True
}
prefs = {
    'printing.print_preview_sticky_settings.appState': json.dumps(settings),
    'savefile.default_directory': download_dir,
    "download.prompt_for_download": False,
    "download.directory_upgrade": True,
    "download.safebrowsing.enabled": True
}
options.add_experimental_option('prefs', prefs)
options.add_argument('--kiosk-printing')

try:
    print("-&gt; Configuration du pilote Chrome...")
    service = Service(ChromeDriverManager().install())
    driver = webdriver.Chrome(service=service, options=options)
    
    print("-&gt; Activation du mode discret...")
    stealth(driver,
            languages=["fr-FR", "fr"],
            vendor="Google Inc.",
            platform="Win32",
            webgl_vendor="Intel Inc.",
            renderer="Intel Iris OpenGL Engine",
            fix_hairline=True,
            )
    
    return driver
except Exception as e:
    print(f"ERREUR : Impossible de démarrer Chrome.")
    print(f"Détail de l'erreur : {e}")
    return None

def discover_gemini_urls(driver, scroll_attempts): """Navigue et récupère tous les liens de conversation.""" print("\n--- Démarrage de la découverte automatique des URLs ---") driver.get("https://gemini.google.com/app")

wait = WebDriverWait(driver, 60)

try:
    print("-&gt; Attente du chargement de l'interface principale...")
    wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "rich-textarea")))
    print("-&gt; Interface principale détectée.")
    time.sleep(2)

    print("-&gt; Attente de l'apparition de l'historique des conversations...")
    first_link_selector = "a[href*='/app/c/']"
    wait.until(EC.visibility_of_element_located((By.CSS_SELECTOR, first_link_selector)))
    print("-&gt; Historique détecté et visible.")
    
except TimeoutException:
    print("\nERREUR CRITIQUE : Impossible de trouver l'historique.")
    return []

print(f"-&gt; Défilement pour charger l'historique complet ({scroll_attempts} tentatives)...")
try:
    scroll_target = driver.find_element(By.CSS_SELECTOR, "nav")
    for i in range(scroll_attempts):
        driver.execute_script("arguments[0].scrollTop = arguments[0].scrollHeight", scroll_target)
        print(f"  Défilement du panneau {i+1}/{scroll_attempts}...")
        time.sleep(2)
except NoSuchElementException:
    print("-&gt; Panneau de navigation non trouvé, défilement de la page entière...")
    for i in range(scroll_attempts):
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        print(f"  Défilement de la page {i+1}/{scroll_attempts}...")
        time.sleep(2)

print("-&gt; Recherche de tous les liens de conversation après défilement...")
urls = set()
try:
    links = driver.find_elements(By.CSS_SELECTOR, "a[href*='/app/c/']")
    for link in links:
        href = link.get_attribute('href')
        if href:
            urls.add(href)
except Exception as e:
    print(f"ERREUR inattendue lors de la collecte des liens : {e}")
    return []

print(f"-&gt; {len(urls)} conversations uniques trouvées.")
return list(urls)

def sanitize_filename(title): """Nettoie un titre pour en faire un nom de fichier valide.""" invalid_chars = '<>:"/\|?*' for char in invalid_chars: title = title.replace(char, '_') return title[:150].strip()

def export_chat_to_pdf(driver, url, output_dir): """Navigue vers une URL Gemini et l'exporte en PDF.""" try: print(f"\nTraitement de l'URL : {url.split('/')[-1]}") driver.get(url) print("-> Attente du chargement de la conversation...") wait = WebDriverWait(driver, 30) wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".message-content"))) print("-> Conversation chargée.")

    time.sleep(2)
    page_title = driver.title
    
    if "Gemini" in page_title and len(page_title) &lt; 20:
         chat_id = url.split('/')[-1]
         file_name = f"gemini_chat_{chat_id}.pdf"
    else:
         file_name = sanitize_filename(page_title) + ".pdf"
    
    print(f"-&gt; Lancement de l'impression en PDF...")
    driver.execute_script("window.print();")
    
    time.sleep(5)
    
    print(f"-&gt; Sauvegardé (probablement) sous : {file_name}")
    return True

except TimeoutException:
    print("ERREUR : Le chargement de la page de conversation a pris trop de temps.")
    return False
except Exception as e:
    print(f"ERREUR inattendue lors du traitement de {url}: {e}")
    return False

=============================================================================

SCRIPT PRINCIPAL

=============================================================================

if name == "main": print("========================================") print(" Exportateur de Clavardage Gemini PDF ") print("========================================")

profile_path = CHROME_PROFILE_PATH
if not profile_path or not os.path.exists(profile_path):
    print("\nERREUR : Chemin du profil Chrome non trouvé ou invalide.")
    print("Veuillez le renseigner manuellement dans la variable 'CHROME_PROFILE_PATH'.")
    exit()

print(f"Utilisation du profil Chrome : {profile_path}")
print("IMPORTANT : Assurez-vous que Google Chrome est complètement fermé.")
time.sleep(3)

if not os.path.exists(OUTPUT_DIRECTORY):
    print(f"\nCréation du dossier de sortie : {OUTPUT_DIRECTORY}")
    os.makedirs(OUTPUT_DIRECTORY)

absolute_output_path = os.path.abspath(OUTPUT_DIRECTORY)

driver = setup_driver(profile_path, absolute_output_path)

if driver:
    urls_to_process = []
    if AUTO_DISCOVER_URLS:
        urls_to_process = discover_gemini_urls(driver, SCROLL_ATTEMPTS)
    else:
        urls_to_process = GEMINI_URLS

    if not urls_to_process:
        print("\nAucune URL à traiter. Fin du script.")
    else:
        print(f"\n--- Démarrage de l'exportation de {len(urls_to_process)} conversations ---")
        success_count = 0
        fail_count = 0
        for i, url in enumerate(urls_to_process):
            print(f"\n--- Progression : Conversation {i+1}/{len(urls_to_process)} ---")
            if export_chat_to_pdf(driver, url, absolute_output_path):
                success_count += 1
            else:
                fail_count += 1
        
        print("\n----------------------------------------")
        print("Exportation terminée !")
        print(f"Conversations sauvegardées : {success_count}")
        print(f"Échecs : {fail_count}")
        print(f"Les fichiers PDF se trouvent dans : {absolute_output_path}")
    
    driver.quit()

Pour citer ce code :

Loyer, Dominique. (2024). export_gemini copie.py [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html

        <!-- Bloc pour export_gemini.py -->
        <article class="bg-white rounded-lg shadow-lg overflow-hidden">
            <header class="p-5 bg-gray-800 text-white">
                <h2 class="text-2xl font-semibold">export_gemini.py</h2>
                <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
            </header>
            <div class="p-5">
                <pre><code class="language-python"># -*- coding: utf-8 -*-

=============================================================================

EXPORTATEUR DE CLAVARDAGE GEMINI EN PDF (v2.9 - Installation en 2 temps)

Description :

Ce script installe ses dépendances au premier lancement, puis s'exécute

au second lancement. C'est la méthode la plus fiable pour éviter les

erreurs de 'ModuleNotFoundError' après une installation.

Auteur : Gemini

Version : 2.9

=============================================================================

import sys import subprocess import os import time import json import platform

=============================================================================

DÉPENDANCES ET INSTALLATION AUTOMATIQUE

=============================================================================

def check_and_install_packages(): """Vérifie et installe les paquets. Si une installation a lieu, le script demandera à être relancé.""" required_packages = { 'selenium': 'selenium', 'stealth': 'selenium-stealth', 'webdriver_manager': 'webdriver-manager' }

print("--- Vérification des dépendances ---")
installations_made = False
for package_import, package_name in required_packages.items():
    try:
        __import__(package_import)
        print(f"[✓] {package_name} est déjà installé.")
    except ImportError:
        print(f"[!] {package_name} est manquant. Tentative d'installation...")
        installations_made = True
        try:
            subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
            print(f"[✓] {package_name} a été installé avec succès.")
        except subprocess.CalledProcessError as e:
            print(f"[X] ERREUR : Impossible d'installer {package_name}.")
            exit()

# Si une installation a eu lieu, on quitte pour permettre au script d'être relancé
if installations_made:
    print("\n---------------------------------------------------------")
    print("  Installation terminée. Veuillez relancer le script.")
    print("---------------------------------------------------------")
    exit()
    
print("--- Toutes les dépendances sont prêtes. ---\n")

Lancer la vérification au démarrage du script

check_and_install_packages()

Les imports sont maintenant faits en toute sécurité

from selenium import webdriver from selenium.webdriver.chrome.service import Service from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from selenium.common.exceptions import TimeoutException, NoSuchElementException from webdriver_manager.chrome import ChromeDriverManager from stealth import stealth

=============================================================================

SECTION DE CONFIGURATION (ACTION REQUISE)

=============================================================================

!! IMPORTANT !!

1. FERMEZ COMPLÈTEMENT GOOGLE CHROME AVANT DE LANCER LE SCRIPT.

(Clic droit sur l'icône dans le Dock -> Quitter)

2. Le chemin de votre profil Chrome est déjà configuré.

CHROME_PROFILE_PATH = "/Users/bk280625/Library/Application Support/Google/Chrome"

3. Découverte automatique des URLs (recommandé)

AUTO_DISCOVER_URLS = True

4. (Optionnel) Liste manuelle si AUTO_DISCOVER_URLS = False

GEMINI_URLS = []

5. Dossier où sauvegarder les PDFs.

OUTPUT_DIRECTORY = "Gemini_Exports_PDF"

6. Nombre de fois où faire défiler la page pour charger l'historique.

SCROLL_ATTEMPTS = 30

=============================================================================

FONCTIONS DU SCRIPT (NE PAS MODIFIER)

=============================================================================

def setup_driver(profile_path, download_dir): """Configure le pilote Chrome avec le gestionnaire auto, le profil et le mode discret.""" options = webdriver.ChromeOptions() options.add_argument(f"user-data-dir={profile_path}") options.add_argument("--disable-blink-features=AutomationControlled") options.add_experimental_option("excludeSwitches", ["enable-automation"]) options.add_experimental_option('useAutomationExtension', False)

settings = {
    "recentDestinations": [{"id": "Save as PDF", "origin": "local", "account": ""}],
    "selectedDestinationId": "Save as PDF",
    "version": 2,
    "isHeaderFooterEnabled": False,
    "isCssBackgroundEnabled": True
}
prefs = {
    'printing.print_preview_sticky_settings.appState': json.dumps(settings),
    'savefile.default_directory': download_dir,
    "download.prompt_for_download": False,
    "download.directory_upgrade": True,
    "download.safebrowsing.enabled": True
}
options.add_experimental_option('prefs', prefs)
options.add_argument('--kiosk-printing')

try:
    print("-&gt; Configuration du pilote Chrome...")
    service = Service(ChromeDriverManager().install())
    driver = webdriver.Chrome(service=service, options=options)
    
    print("-&gt; Activation du mode discret...")
    stealth(driver,
            languages=["fr-FR", "fr"],
            vendor="Google Inc.",
            platform="Win32",
            webgl_vendor="Intel Inc.",
            renderer="Intel Iris OpenGL Engine",
            fix_hairline=True,
            )
    
    return driver
except Exception as e:
    print(f"ERREUR : Impossible de démarrer Chrome.")
    print(f"Détail de l'erreur : {e}")
    return None

def discover_gemini_urls(driver, scroll_attempts): """Navigue et récupère tous les liens de conversation.""" print("\n--- Démarrage de la découverte automatique des URLs ---") driver.get("https://gemini.google.com/app")

wait = WebDriverWait(driver, 60)

try:
    print("-&gt; Attente du chargement de l'interface principale...")
    wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "rich-textarea")))
    print("-&gt; Interface principale détectée.")
    time.sleep(2)

    print("-&gt; Attente de l'apparition de l'historique des conversations...")
    first_link_selector = "a[href*='/app/c/']"
    wait.until(EC.visibility_of_element_located((By.CSS_SELECTOR, first_link_selector)))
    print("-&gt; Historique détecté et visible.")
    
except TimeoutException:
    print("\nERREUR CRITIQUE : Impossible de trouver l'historique.")
    return []

print(f"-&gt; Défilement pour charger l'historique complet ({scroll_attempts} tentatives)...")
try:
    scroll_target = driver.find_element(By.CSS_SELECTOR, "nav")
    for i in range(scroll_attempts):
        driver.execute_script("arguments[0].scrollTop = arguments[0].scrollHeight", scroll_target)
        print(f"  Défilement du panneau {i+1}/{scroll_attempts}...")
        time.sleep(2)
except NoSuchElementException:
    print("-&gt; Panneau de navigation non trouvé, défilement de la page entière...")
    for i in range(scroll_attempts):
        driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
        print(f"  Défilement de la page {i+1}/{scroll_attempts}...")
        time.sleep(2)

print("-&gt; Recherche de tous les liens de conversation après défilement...")
urls = set()
try:
    links = driver.find_elements(By.CSS_SELECTOR, "a[href*='/app/c/']")
    for link in links:
        href = link.get_attribute('href')
        if href:
            urls.add(href)
except Exception as e:
    print(f"ERREUR inattendue lors de la collecte des liens : {e}")
    return []

print(f"-&gt; {len(urls)} conversations uniques trouvées.")
return list(urls)

def sanitize_filename(title): """Nettoie un titre pour en faire un nom de fichier valide.""" invalid_chars = '<>:"/\|?*' for char in invalid_chars: title = title.replace(char, '_') return title[:150].strip()

def export_chat_to_pdf(driver, url, output_dir): """Navigue vers une URL Gemini et l'exporte en PDF.""" try: print(f"\nTraitement de l'URL : {url.split('/')[-1]}") driver.get(url) print("-> Attente du chargement de la conversation...") wait = WebDriverWait(driver, 30) wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".message-content"))) print("-> Conversation chargée.")

    time.sleep(2)
    page_title = driver.title
    
    if "Gemini" in page_title and len(page_title) &lt; 20:
         chat_id = url.split('/')[-1]
         file_name = f"gemini_chat_{chat_id}.pdf"
    else:
         file_name = sanitize_filename(page_title) + ".pdf"
    
    print(f"-&gt; Lancement de l'impression en PDF...")
    driver.execute_script("window.print();")
    
    time.sleep(5)
    
    print(f"-&gt; Sauvegardé (probablement) sous : {file_name}")
    return True

except TimeoutException:
    print("ERREUR : Le chargement de la page de conversation a pris trop de temps.")
    return False
except Exception as e:
    print(f"ERREUR inattendue lors du traitement de {url}: {e}")
    return False

=============================================================================

SCRIPT PRINCIPAL

=============================================================================

if name == "main": print("========================================") print(" Exportateur de Clavardage Gemini PDF ") print("========================================")

profile_path = CHROME_PROFILE_PATH
if not profile_path or not os.path.exists(profile_path):
    print("\nERREUR : Chemin du profil Chrome non trouvé ou invalide.")
    print("Veuillez le renseigner manuellement dans la variable 'CHROME_PROFILE_PATH'.")
    exit()

print(f"Utilisation du profil Chrome : {profile_path}")
print("IMPORTANT : Assurez-vous que Google Chrome est complètement fermé.")
time.sleep(3)

if not os.path.exists(OUTPUT_DIRECTORY):
    print(f"\nCréation du dossier de sortie : {OUTPUT_DIRECTORY}")
    os.makedirs(OUTPUT_DIRECTORY)

absolute_output_path = os.path.abspath(OUTPUT_DIRECTORY)

driver = setup_driver(profile_path, absolute_output_path)

if driver:
    urls_to_process = []
    if AUTO_DISCOVER_URLS:
        urls_to_process = discover_gemini_urls(driver, SCROLL_ATTEMPTS)
    else:
        urls_to_process = GEMINI_URLS

    if not urls_to_process:
        print("\nAucune URL à traiter. Fin du script.")
    else:
        print(f"\n--- Démarrage de l'exportation de {len(urls_to_process)} conversations ---")
        success_count = 0
        fail_count = 0
        for i, url in enumerate(urls_to_process):
            print(f"\n--- Progression : Conversation {i+1}/{len(urls_to_process)} ---")
            if export_chat_to_pdf(driver, url, absolute_output_path):
                success_count += 1
            else:
                fail_count += 1
        
        print("\n----------------------------------------")
        print("Exportation terminée !")
        print(f"Conversations sauvegardées : {success_count}")
        print(f"Échecs : {fail_count}")
        print(f"Les fichiers PDF se trouvent dans : {absolute_output_path}")
    
    driver.quit()

Pour citer ce code :

Loyer, Dominique. (2024). export_gemini.py [Code source]. Repris de https://dominiqueloyer.github.io/Codes.html

        <!-- Bloc pour extraire_fichiers copie (trashed 2025-05-30 11-48-03) copie.py -->
        <article class="bg-white rounded-lg shadow-lg overflow-hidden">
            <header class="p-5 bg-gray-800 text-white">
                <h2 class="text-2xl font-semibold">extraire_fichiers copie (trashed 2025-05-30 11-48-03) copie.py</h2>
                <p class="text-gray-300 mt-1">Erreur lors de la génération de la description.</p>
                <p class="text-xs text-gray-400 mt-2">Mots-clés: erreur, api</p>
            </header>
            <div class="p-5">
                <pre><code class="language-python">

<!DOCTYPE html> <html lang="en"

data-color-mode="dark" data-light-theme="light" data-dark-theme="dark" data-a11y-animated-images="system" data-a11y-link-underlines="true"

>

&lt;link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-primitives-225433424a87.css" /&gt;
&lt;link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-93aded0ee8a1.css" /&gt;
&lt;link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/global-21a7f868f707.css" /&gt;
&lt;link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/github-15d4b28ab680.css" /&gt;

<title>Solr_utilisation/extraire_fichiers.py at main · Alimiji/Solr_utilisation</title>

&lt;meta name="hovercard-subject-tag" content="repository:892964695" data-turbo-transient&gt;

&lt;meta name="google-site-verification" content="Apib7-x98H0j5cPqHWwSMm6dNU4GmODRoqxLiDzdx9I"&gt;

&lt;meta name="user-login" content="DominiqueLoyer"&gt;

&lt;meta name="viewport" content="width=device-width"&gt;



  &lt;meta name="description" content="Ce projet nous montre un exemple d&amp;#39;utilisation de Solr - Solr_utilisation/extraire_fichiers.py at main · Alimiji/Solr_utilisation"&gt;

  &lt;link rel="search" type="application/opensearchdescription+xml" href="/opensearch.xml" title="GitHub"&gt;

&lt;link rel="fluid-icon" href="https://github.com/fluidicon.png" title="GitHub"&gt;
&lt;meta property="fb:app_id" content="1401488693436528"&gt;
&lt;meta name="apple-itunes-app" content="app-id=1477376905, app-argument=https://github.com/Alimiji/Solr_utilisation/blob/main/extraire_fichiers.py" /&gt;

  &lt;meta name="twitter:image" content="https://opengraph.githubassets.com/4ccf9c53fd20503f38ce19dc442ceebebeea1834aa4f9b7cc88751567a72a268/Alimiji/Solr_utilisation" /&gt;&lt;meta name="twitter:site" content="@github" /&gt;&lt;meta name="twitter:card" content="summary_large_image" /&gt;&lt;meta name="twitter:title" content="Solr_utilisation/extraire_fichiers.py at main · Alimiji/Solr_utilisation" /&gt;&lt;meta name="twitter:description" content="Ce projet nous montre un exemple d&amp;#39;utilisation de Solr - Alimiji/Solr_utilisation" /&gt;

  &lt;link rel="shared-web-socket" href="wss://alive.github.com/_sockets/u/10522492/ws?session=eyJ2IjoiVjMiLCJ1IjoxMDUyMjQ5MiwicyI6MTYwOTYzMTE0MywiYyI6MTAxMzYyMzUxOCwidCI6MTc0MTIwMDY3NX0=--6e334a30dae31fb8dd1f229fcbdc5b8412072ae39d88ce1a32c2e98f9aa1d786" data-refresh-url="/_alive" data-session-id="6423c81dedc4cb8d1d43f54226f2835dbbd8262cefb6a037bf5d0ee16212847a"&gt;
  &lt;link rel="shared-web-socket-src" href="/assets-cdn/worker/socket-worker-eff89a71ae86.js"&gt;


  &lt;meta name="hostname" content="github.com"&gt;


  &lt;meta name="keyboard-shortcuts-preference" content="all"&gt;
  &lt;meta name="hovercards-preference" content="true"&gt;
  &lt;meta name="announcement-preference-hovercard" content="true"&gt;

    &lt;meta name="expected-hostname" content="github.com"&gt;

  &lt;meta name="turbo-cache-control" content="no-cache" data-turbo-transient&gt;

&lt;meta data-hydrostats="publish"&gt;

&lt;meta name="turbo-body-classes" content="logged-in env-production page-responsive"&gt;

</head>

&lt;div class="position-relative header-wrapper js-header-wrapper "&gt;
  &lt;a href="#start-of-content" data-skip-target-assigned="false" class="p-3 color-bg-accent-emphasis color-fg-on-emphasis show-on-focus js-skip-to-content"&gt;Skip to content&lt;/a&gt;

  &lt;span data-view-component="true" class="progress-pjax-loader Progress position-fixed width-full"&gt;
&lt;span style="width: 0%;" data-view-component="true" class="Progress-item progress-pjax-loader-bar left-0 top-0 color-bg-accent-emphasis"&gt;&lt;/span&gt;

</span>

  &lt;script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_ui-commands_ui-commands_ts-97496b0f52ba.js"&gt;&lt;/script&gt;

<react-partial partial-name="keyboard-shortcuts-dialog" data-ssr="false" data-attempted-ssr="false" >

          &lt;header class="AppHeader" role="banner"&gt;

<h2 class="sr-only">Navigation Menu</h2>

&lt;div class="AppHeader-globalBar pb-2 js-global-bar"&gt;
  &lt;div class="AppHeader-globalBar-start"&gt;
      &lt;deferred-side-panel data-url="/_side-panels/global"&gt;

<include-fragment data-target="deferred-side-panel.fragment"> <button aria-label="Open global navigation menu" data-action="click:deferred-side-panel#loadPanel click:deferred-side-panel#panelOpened" data-show-dialog-id="dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba" id="dialog-show-dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba" type="button" data-view-component="true" class="Button Button--iconOnly Button--secondary Button--medium AppHeader-button p-0 color-fg-muted"> <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-three-bars Button-visual"> <path d="M1 2.75A.75.75 0 0 1 1.75 2h12.5a.75.75 0 0 1 0 1.5H1.75A.75.75 0 0 1 1 2.75Zm0 5A.75.75 0 0 1 1.75 7h12.5a.75.75 0 0 1 0 1.5H1.75A.75.75 0 0 1 1 7.75ZM1.75 12h12.5a.75.75 0 0 1 0 1.5H1.75a.75.75 0 0 1 0-1.5Z"></path> </svg> </button>

<dialog-helper> <dialog data-target="deferred-side-panel.panel" id="dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba" aria-modal="true" aria-labelledby="dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba-title" aria-describedby="dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba-description" data-view-component="true" class="Overlay Overlay-whenNarrow Overlay--size-small-portrait Overlay--motion-scaleFade Overlay--placement-left SidePanel Overlay--disableScroll"> <div styles="flex-direction: row;" data-view-component="true" class="Overlay-header"> <div class="Overlay-headerContentWrap"> <div class="Overlay-titleWrap"> <h1 class="Overlay-title sr-only" id="dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba-title"> Global navigation </h1> <div data-view-component="true" class="d-flex"> <div data-view-component="true" class="AppHeader-logo position-relative"> <svg aria-hidden="true" height="24" viewBox="0 0 24 24" version="1.1" width="24" data-view-component="true" class="octicon octicon-mark-github"> <path d="M12.5.75C6.146.75 1 5.896 1 12.25c0 5.089 3.292 9.387 7.863 10.91.575.101.79-.244.79-.546 0-.273-.014-1.178-.014-2.142-2.889.532-3.636-.704-3.866-1.35-.13-.331-.69-1.352-1.18-1.625-.402-.216-.977-.748-.014-.762.906-.014 1.553.834 1.769 1.179 1.035 1.74 2.688 1.25 3.349.948.1-.747.402-1.25.733-1.538-2.559-.287-5.232-1.279-5.232-5.678 0-1.25.445-2.285 1.178-3.09-.115-.288-.517-1.467.115-3.048 0 0 .963-.302 3.163 1.179.92-.259 1.897-.388 2.875-.388.977 0 1.955.13 2.875.388 2.2-1.495 3.162-1.179 3.162-1.179.633 1.581.23 2.76.115 3.048.733.805 1.179 1.825 1.179 3.09 0 4.413-2.688 5.39-5.247 5.678.417.36.776 1.05.776 2.128 0 1.538-.014 2.774-.014 3.162 0 .302.216.662.79.547C20.709 21.637 24 17.324 24 12.25 24 5.896 18.854.75 12.5.75Z"></path> </svg> </div></div> </div> <div class="Overlay-actionWrap"> <button data-close-dialog-id="dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba" aria-label="Close" type="button" data-view-component="true" class="close-button Overlay-closeButton"><svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x"> <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path> </svg></button> </div> </div>

</div> <scrollable-region data-labelled-by="dialog-764be29d-8e3e-48d6-83d7-a08bdb0124ba-title"> <div data-view-component="true" class="Overlay-body d-flex flex-column px-2"> <div data-view-component="true" class="d-flex flex-column mb-3"> <nav aria-label="Site navigation" data-view-component="true" class="ActionList">

<nav-list> <ul data-target="nav-list.topLevelList" data-view-component="true" class="ActionListWrap">

&lt;a data-hotkey="g d" data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;HOME&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-566bcd64-5314-4cc1-9879-49a7e769834d" href="/dashboard" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-home"&gt;
&lt;path d="M6.906.664a1.749 1.749 0 0 1 2.187 0l5.25 4.2c.415.332.657.835.657 1.367v7.019A1.75 1.75 0 0 1 13.25 15h-3.5a.75.75 0 0 1-.75-.75V9H7v5.25a.75.75 0 0 1-.75.75h-3.5A1.75 1.75 0 0 1 1 13.25V6.23c0-.531.242-1.034.657-1.366l5.25-4.2Zm1.25 1.171a.25.25 0 0 0-.312 0l-5.25 4.2a.25.25 0 0 0-.094.196v7.019c0 .138.112.25.25.25H5.5V8.25a.75.75 0 0 1 .75-.75h3.5a.75.75 0 0 1 .75.75v5.25h2.75a.25.25 0 0 0 .25-.25V6.23a.25.25 0 0 0-.094-.195Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Home

</span>
</a>

</li>

&lt;a data-hotkey="g i" data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;ISSUES&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-13c00cba-b6a0-414f-ac68-3e5a2756bb04" href="/issues" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-issue-opened"&gt;
&lt;path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"&gt;&lt;/path&gt;&lt;path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Issues

</span>
</a>

</li>

&lt;a data-hotkey="g p" data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;PULL_REQUESTS&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-f6846ebc-7fb5-4a24-92c9-2ebd6668a1a9" href="/pulls" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-pull-request"&gt;
&lt;path d="M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Pull requests

</span>
</a>

</li>

&lt;a data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;PROJECTS&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-57b9c7dd-fddc-486e-b6e9-ec8e6b7a25d2" href="/projects" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-table"&gt;
&lt;path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v12.5A1.75 1.75 0 0 1 14.25 16H1.75A1.75 1.75 0 0 1 0 14.25ZM6.5 6.5v8h7.75a.25.25 0 0 0 .25-.25V6.5Zm8-1.5V1.75a.25.25 0 0 0-.25-.25H6.5V5Zm-13 1.5v7.75c0 .138.112.25.25.25H5v-8ZM5 5V1.5H1.75a.25.25 0 0 0-.25.25V5Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Projects

</span>
</a>

</li>

&lt;a data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;DISCUSSIONS&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-d7b5c37d-77d9-4e4f-81c6-af46eb1762fe" href="/discussions" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-comment-discussion"&gt;
&lt;path d="M1.75 1h8.5c.966 0 1.75.784 1.75 1.75v5.5A1.75 1.75 0 0 1 10.25 10H7.061l-2.574 2.573A1.458 1.458 0 0 1 2 11.543V10h-.25A1.75 1.75 0 0 1 0 8.25v-5.5C0 1.784.784 1 1.75 1ZM1.5 2.75v5.5c0 .138.112.25.25.25h1a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h3.5a.25.25 0 0 0 .25-.25v-5.5a.25.25 0 0 0-.25-.25h-8.5a.25.25 0 0 0-.25.25Zm13 2a.25.25 0 0 0-.25-.25h-.5a.75.75 0 0 1 0-1.5h.5c.966 0 1.75.784 1.75 1.75v5.5A1.75 1.75 0 0 1 14.25 12H14v1.543a1.458 1.458 0 0 1-2.487 1.03L9.22 12.28a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215l2.22 2.22v-2.19a.75.75 0 0 1 .75-.75h1a.25.25 0 0 0 .25-.25Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Discussions

</span>
</a>

</li>

&lt;a data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;CODESPACES&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-ec04c48b-5395-41b9-a76f-fc066f0d9c3a" href="https://github.com/codespaces" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-codespaces"&gt;
&lt;path d="M0 11.25c0-.966.784-1.75 1.75-1.75h12.5c.966 0 1.75.784 1.75 1.75v3A1.75 1.75 0 0 1 14.25 16H1.75A1.75 1.75 0 0 1 0 14.25Zm2-9.5C2 .784 2.784 0 3.75 0h8.5C13.216 0 14 .784 14 1.75v5a1.75 1.75 0 0 1-1.75 1.75h-8.5A1.75 1.75 0 0 1 2 6.75Zm1.75-.25a.25.25 0 0 0-.25.25v5c0 .138.112.25.25.25h8.5a.25.25 0 0 0 .25-.25v-5a.25.25 0 0 0-.25-.25Zm-2 9.5a.25.25 0 0 0-.25.25v3c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25v-3a.25.25 0 0 0-.25-.25Z"&gt;&lt;/path&gt;&lt;path d="M7 12.75a.75.75 0 0 1 .75-.75h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1-.75-.75Zm-4 0a.75.75 0 0 1 .75-.75h.5a.75.75 0 0 1 0 1.5h-.5a.75.75 0 0 1-.75-.75Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Codespaces

</span>
</a>

</li>

&lt;a data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;COPILOT&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-8552101e-e015-465a-a42b-7132fbad85e3" href="/copilot" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copilot"&gt;
&lt;path d="M7.998 15.035c-4.562 0-7.873-2.914-7.998-3.749V9.338c.085-.628.677-1.686 1.588-2.065.013-.07.024-.143.036-.218.029-.183.06-.384.126-.612-.201-.508-.254-1.084-.254-1.656 0-.87.128-1.769.693-2.484.579-.733 1.494-1.124 2.724-1.261 1.206-.134 2.262.034 2.944.765.05.053.096.108.139.165.044-.057.094-.112.143-.165.682-.731 1.738-.899 2.944-.765 1.23.137 2.145.528 2.724 1.261.566.715.693 1.614.693 2.484 0 .572-.053 1.148-.254 1.656.066.228.098.429.126.612.012.076.024.148.037.218.924.385 1.522 1.471 1.591 2.095v1.872c0 .766-3.351 3.795-8.002 3.795Zm0-1.485c2.28 0 4.584-1.11 5.002-1.433V7.862l-.023-.116c-.49.21-1.075.291-1.727.291-1.146 0-2.059-.327-2.71-.991A3.222 3.222 0 0 1 8 6.303a3.24 3.24 0 0 1-.544.743c-.65.664-1.563.991-2.71.991-.652 0-1.236-.081-1.727-.291l-.023.116v4.255c.419.323 2.722 1.433 5.002 1.433ZM6.762 2.83c-.193-.206-.637-.413-1.682-.297-1.019.113-1.479.404-1.713.7-.247.312-.369.789-.369 1.554 0 .793.129 1.171.308 1.371.162.181.519.379 1.442.379.853 0 1.339-.235 1.638-.54.315-.322.527-.827.617-1.553.117-.935-.037-1.395-.241-1.614Zm4.155-.297c-1.044-.116-1.488.091-1.681.297-.204.219-.359.679-.242 1.614.091.726.303 1.231.618 1.553.299.305.784.54 1.638.54.922 0 1.28-.198 1.442-.379.179-.2.308-.578.308-1.371 0-.765-.123-1.242-.37-1.554-.233-.296-.693-.587-1.713-.7Z"&gt;&lt;/path&gt;&lt;path d="M6.25 9.037a.75.75 0 0 1 .75.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 .75-.75Zm4.25.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 1.5 0Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Copilot

</span>
</a>

</li>

      &lt;li role="presentation" aria-hidden="true" data-view-component="true" class="ActionList-sectionDivider"&gt;&lt;/li&gt;

&lt;a data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;EXPLORE&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-d3ef4c1e-5018-4310-90d5-4ffeb6d24b11" href="/explore" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-telescope"&gt;
&lt;path d="M14.184 1.143v-.001l1.422 2.464a1.75 1.75 0 0 1-.757 2.451L3.104 11.713a1.75 1.75 0 0 1-2.275-.702l-.447-.775a1.75 1.75 0 0 1 .53-2.32L11.682.573a1.748 1.748 0 0 1 2.502.57Zm-4.709 9.32h-.001l2.644 3.863a.75.75 0 1 1-1.238.848l-1.881-2.75v2.826a.75.75 0 0 1-1.5 0v-2.826l-1.881 2.75a.75.75 0 1 1-1.238-.848l2.049-2.992a.746.746 0 0 1 .293-.253l1.809-.87a.749.749 0 0 1 .944.252ZM9.436 3.92h-.001l-4.97 3.39.942 1.63 5.42-2.61Zm3.091-2.108h.001l-1.85 1.26 1.505 2.605 2.016-.97a.247.247 0 0 0 .13-.151.247.247 0 0 0-.022-.199l-1.422-2.464a.253.253 0 0 0-.161-.119.254.254 0 0 0-.197.038ZM1.756 9.157a.25.25 0 0 0-.075.33l.447.775a.25.25 0 0 0 .325.1l1.598-.769-.83-1.436-1.465 1Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Explore

</span>
</a>

</li>

&lt;a data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;MARKETPLACE&amp;quot;,&amp;quot;label&amp;quot;:null}" id="item-ddca775f-9cdd-4be3-8339-fd49506a1b9b" href="/marketplace" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-gift"&gt;
&lt;path d="M2 2.75A2.75 2.75 0 0 1 4.75 0c.983 0 1.873.42 2.57 1.232.268.318.497.668.68 1.042.183-.375.411-.725.68-1.044C9.376.42 10.266 0 11.25 0a2.75 2.75 0 0 1 2.45 4h.55c.966 0 1.75.784 1.75 1.75v2c0 .698-.409 1.301-1 1.582v4.918A1.75 1.75 0 0 1 13.25 16H2.75A1.75 1.75 0 0 1 1 14.25V9.332C.409 9.05 0 8.448 0 7.75v-2C0 4.784.784 4 1.75 4h.55c-.192-.375-.3-.8-.3-1.25ZM7.25 9.5H2.5v4.75c0 .138.112.25.25.25h4.5Zm1.5 0v5h4.5a.25.25 0 0 0 .25-.25V9.5Zm0-4V8h5.5a.25.25 0 0 0 .25-.25v-2a.25.25 0 0 0-.25-.25Zm-7 0a.25.25 0 0 0-.25.25v2c0 .138.112.25.25.25h5.5V5.5h-5.5Zm3-4a1.25 1.25 0 0 0 0 2.5h2.309c-.233-.818-.542-1.401-.878-1.793-.43-.502-.915-.707-1.431-.707ZM8.941 4h2.309a1.25 1.25 0 0 0 0-2.5c-.516 0-1 .205-1.43.707-.337.392-.646.975-.879 1.793Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Marketplace

</span>
</a>

</li>

</ul> </nav-list> </nav>

    &lt;div data-view-component="true" class="my-3 d-flex flex-justify-center height-full"&gt;
      &lt;span data-view-component="true"&gt;

  &lt;div data-view-component="true" class="px-2"&gt;      &lt;p class="color-fg-subtle text-small text-light"&gt;&amp;copy; 2025 GitHub, Inc.&lt;/p&gt;

  &lt;div data-view-component="true" class="d-flex flex-wrap text-small text-light"&gt;
      &lt;a target="_blank" href="https://github.com/about" data-view-component="true" class="Link mr-2"&gt;About&lt;/a&gt;
      &lt;a target="_blank" href="https://github.blog" data-view-component="true" class="Link mr-2"&gt;Blog&lt;/a&gt;
      &lt;a target="_blank" href="https://docs.github.com/site-policy/github-terms/github-terms-of-service" data-view-component="true" class="Link mr-2"&gt;Terms&lt;/a&gt;
      &lt;a target="_blank" href="https://docs.github.com/site-policy/privacy-policies/github-privacy-statement" data-view-component="true" class="Link mr-2"&gt;Privacy&lt;/a&gt;
      &lt;a target="_blank" href="https://github.com/security" data-view-component="true" class="Link mr-2"&gt;Security&lt;/a&gt;
      &lt;a target="_blank" href="https://www.githubstatus.com/" data-view-component="true" class="Link mr-3"&gt;Status&lt;/a&gt;

</div></div> </div> </scrollable-region>

</dialog></dialog-helper>

</include-fragment> </deferred-side-panel>

    &lt;a
      class="AppHeader-logo ml-1"
      href="https://github.com/"
      data-hotkey="g d"
      aria-label="Homepage "
      data-turbo="false"
      data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Header&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;go to dashboard&amp;quot;,&amp;quot;label&amp;quot;:&amp;quot;icon:logo&amp;quot;}"
    &gt;
      &lt;svg height="32" aria-hidden="true" viewBox="0 0 24 24" version="1.1" width="32" data-view-component="true" class="octicon octicon-mark-github v-align-middle"&gt;
&lt;path d="M12.5.75C6.146.75 1 5.896 1 12.25c0 5.089 3.292 9.387 7.863 10.91.575.101.79-.244.79-.546 0-.273-.014-1.178-.014-2.142-2.889.532-3.636-.704-3.866-1.35-.13-.331-.69-1.352-1.18-1.625-.402-.216-.977-.748-.014-.762.906-.014 1.553.834 1.769 1.179 1.035 1.74 2.688 1.25 3.349.948.1-.747.402-1.25.733-1.538-2.559-.287-5.232-1.279-5.232-5.678 0-1.25.445-2.285 1.178-3.09-.115-.288-.517-1.467.115-3.048 0 0 .963-.302 3.163 1.179.92-.259 1.897-.388 2.875-.388.977 0 1.955.13 2.875.388 2.2-1.495 3.162-1.179 3.162-1.179.633 1.581.23 2.76.115 3.048.733.805 1.179 1.825 1.179 3.09 0 4.413-2.688 5.39-5.247 5.678.417.36.776 1.05.776 2.128 0 1.538-.014 2.774-.014 3.162 0 .302.216.662.79.547C20.709 21.637 24 17.324 24 12.25 24 5.896 18.854.75 12.5.75Z"&gt;&lt;/path&gt;

</svg> </a>

      &lt;div class="AppHeader-context" &gt;

<div class="AppHeader-context-compact"> <button aria-expanded="false" aria-haspopup="dialog" aria-label="Page context: Alimiji / Solr_utilisation" id="dialog-show-context-region-dialog" data-show-dialog-id="context-region-dialog" type="button" data-view-component="true" class="AppHeader-context-compact-trigger Truncate Button--secondary Button--medium Button box-shadow-none"> <span class="Button-content"> <span class="Button-label"><span class="AppHeader-context-compact-lead"> <span class="AppHeader-context-compact-parentItem">Alimiji</span> <span class="no-wrap"> /</span>

        &lt;/span&gt;

        &lt;strong class="AppHeader-context-compact-mainItem d-flex flex-items-center Truncate" &gt;

<span class="Truncate-text ">Solr_utilisation</span>

</strong></span> </span> </button>

<dialog-helper> <dialog id="context-region-dialog" aria-modal="true" aria-labelledby="context-region-dialog-title" aria-describedby="context-region-dialog-description" data-view-component="true" class="Overlay Overlay-whenNarrow Overlay--size-medium Overlay--motion-scaleFade Overlay--disableScroll"> <div data-view-component="true" class="Overlay-header"> <div class="Overlay-headerContentWrap"> <div class="Overlay-titleWrap"> <h1 class="Overlay-title " id="context-region-dialog-title"> Navigate back to </h1>

&lt;/div&gt;
&lt;div class="Overlay-actionWrap"&gt;
  &lt;button data-close-dialog-id="context-region-dialog" aria-label="Close" type="button" data-view-component="true" class="close-button Overlay-closeButton"&gt;&lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x"&gt;
&lt;path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"&gt;&lt;/path&gt;

</svg></button> </div> </div>

</div> <scrollable-region data-labelled-by="context-region-dialog-title"> <div data-view-component="true" class="Overlay-body"> <ul role="list" class="list-style-none" > <li> <a data-analytics-event="{"category":"SiteHeaderComponent","action":"context_region_crumb","label":"Alimiji","screen_size":"compact"}" href="/Alimiji" data-view-component="true" class="Link--primary Truncate d-flex flex-items-center py-1"> <span class="AppHeader-context-item-label Truncate-text "> <svg aria-hidden="true" height="12" viewBox="0 0 16 16" version="1.1" width="12" data-view-component="true" class="octicon octicon-person mr-1"> <path d="M10.561 8.073a6.005 6.005 0 0 1 3.432 5.142.75.75 0 1 1-1.498.07 4.5 4.5 0 0 0-8.99 0 .75.75 0 0 1-1.498-.07 6.004 6.004 0 0 1 3.431-5.142 3.999 3.999 0 1 1 5.123 0ZM10.5 5a2.5 2.5 0 1 0-5 0 2.5 2.5 0 0 0 5 0Z"></path> </svg>

      Alimiji
    &lt;/span&gt;

</a> </li> <li> <a data-analytics-event="{"category":"SiteHeaderComponent","action":"context_region_crumb","label":"Solr_utilisation","screen_size":"compact"}" href="/Alimiji/Solr_utilisation" data-view-component="true" class="Link--primary Truncate d-flex flex-items-center py-1"> <span class="AppHeader-context-item-label Truncate-text "> <svg aria-hidden="true" height="12" viewBox="0 0 16 16" version="1.1" width="12" data-view-component="true" class="octicon octicon-repo mr-1"> <path d="M2 2.5A2.5 2.5 0 0 1 4.5 0h8.75a.75.75 0 0 1 .75.75v12.5a.75.75 0 0 1-.75.75h-2.5a.75.75 0 0 1 0-1.5h1.75v-2h-8a1 1 0 0 0-.714 1.7.75.75 0 1 1-1.072 1.05A2.495 2.495 0 0 1 2 11.5Zm10.5-1h-8a1 1 0 0 0-1 1v6.708A2.486 2.486 0 0 1 4.5 9h8ZM5 12.25a.25.25 0 0 1 .25-.25h3.5a.25.25 0 0 1 .25.25v3.25a.25.25 0 0 1-.4.2l-1.45-1.087a.249.249 0 0 0-.3 0L5.4 15.7a.25.25 0 0 1-.4-.2Z"></path> </svg>

      Solr_utilisation
    &lt;/span&gt;

</a> </li> </ul>

</div> </scrollable-region>

</dialog></dialog-helper> </div>

      Alimiji
    &lt;/span&gt;

</a> <span class="AppHeader-context-item-separator"> <span class='sr-only'>/</span> <svg width="16" height="16" viewBox="0 0 16 16" xmlns="http://www.w3.org/2000/svg" aria-hidden="true"> <path d="M10.956 1.27994L6.06418 14.7201L5 14.7201L9.89181 1.27994L10.956 1.27994Z" fill="currentcolor"/> </svg> </span> </li> <li> <a data-analytics-event="{"category":"SiteHeaderComponent","action":"context_region_crumb","label":"Solr_utilisation","screen_size":"full"}" href="/Alimiji/Solr_utilisation" data-view-component="true" class="AppHeader-context-item"> <span class="AppHeader-context-item-label ">

      Solr_utilisation
    &lt;/span&gt;

</a> </li> </ul>

&lt;/nav&gt;

</div> </div>

  &lt;/div&gt;
  &lt;div class="AppHeader-globalBar-end"&gt;
      &lt;div class="AppHeader-search" &gt;

<qbsearch-input class="search-input" data-scope="repo:Alimiji/Solr_utilisation" data-custom-scopes-path="/search/custom_scopes" data-delete-custom-scopes-csrf="rdhqNea0-49_T7LtfH--8cngXgfDZcScRPssEKqah0KHtWNTLIaO2go46nYCM5GJloMJHw1wkvV_ld96PgSHoA" data-max-custom-scopes="10" data-header-redesign-enabled="true" data-initial-value="" data-blackbird-suggestions-path="/search/suggestions" data-jump-to-suggestions-path="/_graphql/GetSuggestedNavigationDestinations" data-current-repository="Alimiji/Solr_utilisation" data-current-org="" data-current-owner="Alimiji" data-logged-in="true" data-copilot-chat-enabled="true" data-nl-search-enabled="false"> <div class="search-input-container search-with-dialog position-relative d-flex flex-row flex-items-center height-auto color-bg-transparent border-0 color-fg-subtle mx-0" data-action="click:qbsearch-input#searchInputContainerClicked" >

        &lt;button type="button" data-action="click:qbsearch-input#handleExpand" class="AppHeader-button AppHeader-search-whenNarrow" aria-label="Search or jump to…" aria-expanded="false" aria-haspopup="dialog"&gt;
        &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-search"&gt;
&lt;path d="M10.68 11.74a6 6 0 0 1-7.922-8.982 6 6 0 0 1 8.982 7.922l3.04 3.04a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215ZM11.5 7a4.499 4.499 0 1 0-8.997 0A4.499 4.499 0 0 0 11.5 7Z"&gt;&lt;/path&gt;

</svg> </button>

            &lt;button
        type="button"
        data-target="qbsearch-input.inputButton"
        data-action="click:qbsearch-input#handleExpand"
        class="AppHeader-searchButton form-control input-contrast text-left color-fg-subtle no-wrap"
        data-hotkey="s,/"
        data-analytics-event="{&amp;quot;location&amp;quot;:&amp;quot;navbar&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;searchbar&amp;quot;,&amp;quot;context&amp;quot;:&amp;quot;global&amp;quot;,&amp;quot;tag&amp;quot;:&amp;quot;input&amp;quot;,&amp;quot;label&amp;quot;:&amp;quot;searchbar_input_global_navbar&amp;quot;}"
        aria-describedby="search-error-message-flash"
      &gt;
        &lt;div class="overflow-hidden"&gt;
          &lt;span id="qb-input-query" data-target="qbsearch-input.inputButtonText"&gt;
              Type &lt;kbd class="AppHeader-search-kbd"&gt;/&lt;/kbd&gt; to search
          &lt;/span&gt;
        &lt;/div&gt;
      &lt;/button&gt;

&lt;/div&gt;

</div> </div>

&lt;input type="hidden" name="type" class="js-site-search-type-field"&gt;

<div class="Overlay--hidden " data-modal-dialog-overlay> <modal-dialog data-action="close:qbsearch-input#handleClose cancel:qbsearch-input#handleClose" data-target="qbsearch-input.searchSuggestionsDialog" role="dialog" id="search-suggestions-dialog" aria-modal="true" aria-labelledby="search-suggestions-dialog-header" data-view-component="true" class="Overlay Overlay--width-medium Overlay--height-auto"> <h1 id="search-suggestions-dialog-header" class="sr-only">Search code, repositories, users, issues, pull requests...</h1> <div class="Overlay-body Overlay-body--paddingNone">

      &lt;div data-view-component="true"&gt;        &lt;div class="search-suggestions position-absolute width-full color-shadow-large border color-fg-default color-bg-default overflow-hidden d-flex flex-column query-builder-container"
      style="border-radius: 12px;"
      data-target="qbsearch-input.queryBuilderContainer"
      hidden
    &gt;
      &lt;!-- '"` --&gt;&lt;!-- &lt;/textarea&gt;&lt;/xmp&gt; --&gt;&lt;/option&gt;&lt;/form&gt;&lt;form id="query-builder-test-form" action="" accept-charset="UTF-8" method="get"&gt;

<query-builder data-target="qbsearch-input.queryBuilder" id="query-builder-query-builder-test" data-filter-key=":" data-view-component="true" class="QueryBuilder search-query-builder"> <div class="FormControl FormControl--fullWidth"> <label id="query-builder-test-label" for="query-builder-test" class="FormControl-label sr-only"> Search </label> <div class="QueryBuilder-StyledInput width-fit " data-target="query-builder.styledInput" > <span id="query-builder-test-leadingvisual-wrap" class="FormControl-input-leadingVisualWrap QueryBuilder-leadingVisualWrap"> <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-search FormControl-input-leadingVisual"> <path d="M10.68 11.74a6 6 0 0 1-7.922-8.982 6 6 0 0 1 8.982 7.922l3.04 3.04a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215ZM11.5 7a4.499 4.499 0 1 0-8.997 0A4.499 4.499 0 0 0 11.5 7Z"></path> </svg> </span> <div data-target="query-builder.styledInputContainer" class="QueryBuilder-StyledInputContainer"> <div aria-hidden="true" class="QueryBuilder-StyledInputContent" data-target="query-builder.styledInputContent" ></div> <div class="QueryBuilder-InputWrapper"> <div aria-hidden="true" class="QueryBuilder-Sizer" data-target="query-builder.sizer"></div> <input id="query-builder-test" name="query-builder-test" value="" autocomplete="off" type="text" role="combobox" spellcheck="false" aria-expanded="false" aria-describedby="validation-d9842016-babf-4885-ab02-96c584c5e287" data-target="query-builder.input" data-action=" input:query-builder#inputChange blur:query-builder#inputBlur keydown:query-builder#inputKeydown focus:query-builder#inputFocus " data-view-component="true" class="FormControl-input QueryBuilder-Input FormControl-medium" /> </div> </div> <span class="sr-only" id="query-builder-test-clear">Clear</span> <button role="button" id="query-builder-test-clear-button" aria-labelledby="query-builder-test-clear query-builder-test-label" data-target="query-builder.clearButton" data-action=" click:query-builder#clear focus:query-builder#clearButtonFocus blur:query-builder#clearButtonBlur " variant="small" hidden="hidden" type="button" data-view-component="true" class="Button Button--iconOnly Button--invisible Button--medium mr-1 px-2 py-0 d-flex flex-items-center rounded-1 color-fg-muted"> <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x-circle-fill Button-visual"> <path d="M2.343 13.657A8 8 0 1 1 13.658 2.343 8 8 0 0 1 2.343 13.657ZM6.03 4.97a.751.751 0 0 0-1.042.018.751.751 0 0 0-.018 1.042L6.94 8 4.97 9.97a.749.749 0 0 0 .326 1.275.749.749 0 0 0 .734-.215L8 9.06l1.97 1.97a.749.749 0 0 0 1.275-.326.749.749 0 0 0-.215-.734L9.06 8l1.97-1.97a.749.749 0 0 0-.326-1.275.749.749 0 0 0-.734.215L8 6.94Z"></path> </svg> </button>

  &lt;/div&gt;
  &lt;template id="search-icon"&gt;

    &lt;div class="position-relative"&gt;
            &lt;ul
              role="listbox"
              class="ActionListWrap QueryBuilder-ListWrap"
              aria-label="Suggestions"
              data-action="
                combobox-commit:query-builder#comboboxCommit
                mousedown:query-builder#resultsMousedown
              "
              data-target="query-builder.resultsList"
              data-persist-list=false
              id="query-builder-test-results"
            &gt;&lt;/ul&gt;
    &lt;/div&gt;
  &lt;div class="FormControl-inlineValidation" id="validation-d9842016-babf-4885-ab02-96c584c5e287" hidden="hidden"&gt;
    &lt;span class="FormControl-inlineValidation--visual"&gt;
      &lt;svg aria-hidden="true" height="12" viewBox="0 0 12 12" version="1.1" width="12" data-view-component="true" class="octicon octicon-alert-fill"&gt;
&lt;path d="M4.855.708c.5-.896 1.79-.896 2.29 0l4.675 8.351a1.312 1.312 0 0 1-1.146 1.954H1.33A1.313 1.313 0 0 1 .183 9.058ZM7 7V3H5v4Zm-1 3a1 1 0 1 0 0-2 1 1 0 0 0 0 2Z"&gt;&lt;/path&gt;

</svg> </span> <span></span> </div> </div> <div data-target="query-builder.screenReaderFeedback" aria-live="polite" aria-atomic="true" class="sr-only"></div> </query-builder></form> <div class="d-flex flex-row color-fg-muted px-3 text-small color-bg-default search-feedback-prompt"> <a target="_blank" href="https://docs.github.com/search-github/github-code-search/understanding-github-code-search-syntax" data-view-component="true" class="Link color-fg-accent text-normal ml-2">Search syntax tips</a> <div class="d-flex flex-1"></div> <button data-action="click:qbsearch-input#showFeedbackDialog" type="button" data-view-component="true" class="Button--link Button--medium Button color-fg-accent text-normal ml-2"> <span class="Button-content"> <span class="Button-label">Give feedback</span> </span> </button> </div> </div> </div>

&lt;/div&gt;

</modal-dialog></div> </div> <div data-action="click:qbsearch-input#retract" class="dark-backdrop position-fixed" hidden data-target="qbsearch-input.darkBackdrop"></div> <div class="color-fg-default">

<dialog-helper> <dialog data-target="qbsearch-input.feedbackDialog" data-action="close:qbsearch-input#handleDialogClose cancel:qbsearch-input#handleDialogClose" id="feedback-dialog" aria-modal="true" aria-labelledby="feedback-dialog-title" aria-describedby="feedback-dialog-description" data-view-component="true" class="Overlay Overlay-whenNarrow Overlay--size-medium Overlay--motion-scaleFade Overlay--disableScroll"> <div data-view-component="true" class="Overlay-header"> <div class="Overlay-headerContentWrap"> <div class="Overlay-titleWrap"> <h1 class="Overlay-title " id="feedback-dialog-title"> Provide feedback </h1>

&lt;/div&gt;
&lt;div class="Overlay-actionWrap"&gt;
  &lt;button data-close-dialog-id="feedback-dialog" aria-label="Close" type="button" data-view-component="true" class="close-button Overlay-closeButton"&gt;&lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x"&gt;
&lt;path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"&gt;&lt;/path&gt;

</svg></button> </div> </div>

</div> <scrollable-region data-labelled-by="feedback-dialog-title"> <div data-view-component="true" class="Overlay-body"> </option></form><form id="code-search-feedback-form" data-turbo="false" action="/search/feedback" accept-charset="UTF-8" method="post"><input type="hidden" name="authenticity_token" value="ZTpqdXLFfpkJrBjOSS9lfojp8rn-KTyQTEd_-ZizBkbxGBfhStEMP65Qqzpcp8CrgrLzWbatqLgLiTUdLy-Izw" /> <p>We read every piece of feedback, and take your input very seriously.</p> <textarea name="feedback" class="form-control width-full mb-2" style="height: 120px" id="feedback"></textarea> <input name="include_email" id="include_email" aria-label="Include my email address so I can be contacted" class="form-control mr-2" type="checkbox"> <label for="include_email" style="font-weight: normal">Include my email address so I can be contacted</label> </form></div> </scrollable-region> <div data-view-component="true" class="Overlay-footer Overlay-footer--alignEnd"> <button data-close-dialog-id="feedback-dialog" type="button" data-view-component="true" class="btn"> Cancel </button> <button form="code-search-feedback-form" data-action="click:qbsearch-input#submitFeedback" type="submit" data-view-component="true" class="btn-primary btn"> Submit feedback </button> </div> </dialog></dialog-helper>

&lt;custom-scopes data-target="qbsearch-input.customScopesManager"&gt;

<dialog-helper> <dialog data-target="custom-scopes.customScopesModalDialog" data-action="close:qbsearch-input#handleDialogClose cancel:qbsearch-input#handleDialogClose" id="custom-scopes-dialog" aria-modal="true" aria-labelledby="custom-scopes-dialog-title" aria-describedby="custom-scopes-dialog-description" data-view-component="true" class="Overlay Overlay-whenNarrow Overlay--size-medium Overlay--motion-scaleFade Overlay--disableScroll"> <div data-view-component="true" class="Overlay-header Overlay-header--divided"> <div class="Overlay-headerContentWrap"> <div class="Overlay-titleWrap"> <h1 class="Overlay-title " id="custom-scopes-dialog-title"> Saved searches </h1> <h2 id="custom-scopes-dialog-description" class="Overlay-description">Use saved searches to filter your results more quickly</h2> </div> <div class="Overlay-actionWrap"> <button data-close-dialog-id="custom-scopes-dialog" aria-label="Close" type="button" data-view-component="true" class="close-button Overlay-closeButton"><svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x"> <path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"></path> </svg></button> </div> </div>

</div> <scrollable-region data-labelled-by="custom-scopes-dialog-title"> <div data-view-component="true" class="Overlay-body"> <div data-target="custom-scopes.customScopesModalDialogFlash"></div>

    &lt;div hidden class="create-custom-scope-form" data-target="custom-scopes.createCustomScopeForm"&gt;
    &lt;!-- '"` --&gt;&lt;!-- &lt;/textarea&gt;&lt;/xmp&gt; --&gt;&lt;/option&gt;&lt;/form&gt;&lt;form id="custom-scopes-dialog-form" data-turbo="false" action="/search/custom_scopes" accept-charset="UTF-8" method="post"&gt;&lt;input type="hidden" name="authenticity_token" value="SXBkbsF5E9vmK3WWTsbUxkrZi2_4L_TKJkpjKL2T8CG0GsgqpLMUoCX-BVJRhpRS4s-Hzndg1GOD9bJFl9zkWQ" /&gt;
      &lt;div data-target="custom-scopes.customScopesModalDialogFlash"&gt;&lt;/div&gt;

      &lt;input type="hidden" id="custom_scope_id" name="custom_scope_id" data-target="custom-scopes.customScopesIdField"&gt;

      &lt;div class="form-group"&gt;
        &lt;label for="custom_scope_name"&gt;Name&lt;/label&gt;
        &lt;auto-check src="/search/custom_scopes/check_name" required only-validate-on-blur="false"&gt;
          &lt;input
            type="text"
            name="custom_scope_name"
            id="custom_scope_name"
            data-target="custom-scopes.customScopesNameField"
            class="form-control"
            autocomplete="off"
            placeholder="github-ruby"
            required
            maxlength="50"&gt;
          &lt;input type="hidden" value="UeNph_pvhwsQUrYnhK6yIc6X4j_9pyzGcEAdVWpcVElJLXWenI1twHWgXXiu5714PE7tOTmtNZu_ULML2OZ8dA" data-csrf="true" /&gt;
        &lt;/auto-check&gt;
      &lt;/div&gt;

      &lt;div class="form-group"&gt;
        &lt;label for="custom_scope_query"&gt;Query&lt;/label&gt;
        &lt;input
          type="text"
          name="custom_scope_query"
          id="custom_scope_query"
          data-target="custom-scopes.customScopesQueryField"
          class="form-control"
          autocomplete="off"
          placeholder="(repo:mona/a OR repo:mona/b) AND lang:python"
          required
          maxlength="500"&gt;
      &lt;/div&gt;

      &lt;p class="text-small color-fg-muted"&gt;
        To see all available qualifiers, see our &lt;a class="Link--inTextBlock" href="https://docs.github.com/search-github/github-code-search/understanding-github-code-search-syntax"&gt;documentation&lt;/a&gt;.
      &lt;/p&gt;

</form> </div>

    &lt;div data-target="custom-scopes.manageCustomScopesForm"&gt;
      &lt;div data-target="custom-scopes.list"&gt;&lt;/div&gt;
    &lt;/div&gt;

</div> </scrollable-region> <div data-view-component="true" class="Overlay-footer Overlay-footer--alignEnd Overlay-footer--divided"> <button data-action="click:custom-scopes#customScopesCancel" type="button" data-view-component="true" class="btn"> Cancel </button> <button form="custom-scopes-dialog-form" data-action="click:custom-scopes#customScopesSubmit" data-target="custom-scopes.customScopesSubmitButton" type="submit" data-view-component="true" class="btn-primary btn"> Create saved search </button> </div> </dialog></dialog-helper> </custom-scopes> </div> </qbsearch-input> <input type="hidden" value="79O93enXNNAI0qKarZtL7YvaPXY__VK5vcLjdbL82TUBiUNHmspXI5YUaAI38KOTMKxmNOgKqeS8FI5qzmTm1A" data-csrf="true" class="js-data-jump-to-suggestions-path-csrf" />

      &lt;/div&gt;

    
      &lt;div class="AppHeader-CopilotChat"&gt;
&lt;react-partial-anchor&gt;
  &lt;button id="copilot-chat-header-button" data-target="react-partial-anchor.anchor" data-hotkey="Shift+C" aria-expanded="false" aria-controls="copilot-chat-panel" aria-labelledby="tooltip-76ff6244-0180-4501-884c-3b7667150ca2" type="button" disabled="disabled" data-view-component="true" class="Button Button--iconOnly Button--secondary Button--medium AppHeader-button AppHeader-buttonLeft cursor-wait"&gt;  &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-copilot Button-visual"&gt;
&lt;path d="M7.998 15.035c-4.562 0-7.873-2.914-7.998-3.749V9.338c.085-.628.677-1.686 1.588-2.065.013-.07.024-.143.036-.218.029-.183.06-.384.126-.612-.201-.508-.254-1.084-.254-1.656 0-.87.128-1.769.693-2.484.579-.733 1.494-1.124 2.724-1.261 1.206-.134 2.262.034 2.944.765.05.053.096.108.139.165.044-.057.094-.112.143-.165.682-.731 1.738-.899 2.944-.765 1.23.137 2.145.528 2.724 1.261.566.715.693 1.614.693 2.484 0 .572-.053 1.148-.254 1.656.066.228.098.429.126.612.012.076.024.148.037.218.924.385 1.522 1.471 1.591 2.095v1.872c0 .766-3.351 3.795-8.002 3.795Zm0-1.485c2.28 0 4.584-1.11 5.002-1.433V7.862l-.023-.116c-.49.21-1.075.291-1.727.291-1.146 0-2.059-.327-2.71-.991A3.222 3.222 0 0 1 8 6.303a3.24 3.24 0 0 1-.544.743c-.65.664-1.563.991-2.71.991-.652 0-1.236-.081-1.727-.291l-.023.116v4.255c.419.323 2.722 1.433 5.002 1.433ZM6.762 2.83c-.193-.206-.637-.413-1.682-.297-1.019.113-1.479.404-1.713.7-.247.312-.369.789-.369 1.554 0 .793.129 1.171.308 1.371.162.181.519.379 1.442.379.853 0 1.339-.235 1.638-.54.315-.322.527-.827.617-1.553.117-.935-.037-1.395-.241-1.614Zm4.155-.297c-1.044-.116-1.488.091-1.681.297-.204.219-.359.679-.242 1.614.091.726.303 1.231.618 1.553.299.305.784.54 1.638.54.922 0 1.28-.198 1.442-.379.179-.2.308-.578.308-1.371 0-.765-.123-1.242-.37-1.554-.233-.296-.693-.587-1.713-.7Z"&gt;&lt;/path&gt;&lt;path d="M6.25 9.037a.75.75 0 0 1 .75.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 .75-.75Zm4.25.75v1.501a.75.75 0 0 1-1.5 0V9.787a.75.75 0 0 1 1.5 0Z"&gt;&lt;/path&gt;

</svg> </button><tool-tip id="tooltip-76ff6244-0180-4501-884c-3b7667150ca2" for="copilot-chat-header-button" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute">Chat with Copilot</tool-tip>

  &lt;template data-target="react-partial-anchor.template"&gt;
    &lt;script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/vendors-node_modules_react-relay_index_js-3e4c69718bad.js"&gt;&lt;/script&gt;

  &lt;template data-target="react-partial-anchor.template"&gt;
    &lt;script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/global-copilot-menu-f997b4b96fc7.js"&gt;&lt;/script&gt;

<react-partial partial-name="global-copilot-menu" data-ssr="false" data-attempted-ssr="false" >

  &lt;/template&gt;
&lt;/react-partial-anchor&gt;

</div>

    &lt;div class="AppHeader-actions position-relative"&gt;
         &lt;react-partial-anchor&gt;
  &lt;button id="global-create-menu-anchor" aria-label="Create something new" data-target="react-partial-anchor.anchor" type="button" disabled="disabled" data-view-component="true" class="AppHeader-button global-create-button cursor-wait Button--secondary Button--medium Button width-auto color-fg-muted"&gt;  &lt;span class="Button-content"&gt;
  &lt;span class="Button-visual Button-leadingVisual"&gt;
    &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-plus"&gt;
&lt;path d="M7.75 2a.75.75 0 0 1 .75.75V7h4.25a.75.75 0 0 1 0 1.5H8.5v4.25a.75.75 0 0 1-1.5 0V8.5H2.75a.75.75 0 0 1 0-1.5H7V2.75A.75.75 0 0 1 7.75 2Z"&gt;&lt;/path&gt;

</svg> </span> <span class="Button-label"><svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-triangle-down"> <path d="m4.427 7.427 3.396 3.396a.25.25 0 0 0 .354 0l3.396-3.396A.25.25 0 0 0 11.396 7H4.604a.25.25 0 0 0-.177.427Z"></path> </svg></span> </span> </button><tool-tip id="tooltip-ed5feb45-0058-4d48-889f-fb3ac351e82f" for="global-create-menu-anchor" popover="manual" data-direction="s" data-type="description" data-view-component="true" class="sr-only position-absolute">Create new...</tool-tip>

  &lt;template data-target="react-partial-anchor.template"&gt;
    &lt;script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/ui_packages_promise-with-resolvers-polyfill_promise-with-resolvers-polyfill_ts-ui_packages_re-8d43b0-ae8dde838777.js"&gt;&lt;/script&gt;

<react-partial partial-name="global-create-menu" data-ssr="false" data-attempted-ssr="false" >

  &lt;/template&gt;
&lt;/react-partial-anchor&gt;


      &lt;a href="/issues" data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;ISSUES_HEADER&amp;quot;,&amp;quot;label&amp;quot;:null}" id="icon-button-09e73c72-2cbc-4558-a2bf-cf207d9ca0cb" aria-labelledby="tooltip-9578566a-4e4f-4396-aa33-40d1d3b0cabc" data-view-component="true" class="Button Button--iconOnly Button--secondary Button--medium AppHeader-button color-fg-muted"&gt;  &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-issue-opened Button-visual"&gt;
&lt;path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"&gt;&lt;/path&gt;&lt;path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z"&gt;&lt;/path&gt;

</svg> </a><tool-tip id="tooltip-9578566a-4e4f-4396-aa33-40d1d3b0cabc" for="icon-button-09e73c72-2cbc-4558-a2bf-cf207d9ca0cb" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute">Your issues</tool-tip>

      &lt;a href="/pulls" data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;PULL_REQUESTS_HEADER&amp;quot;,&amp;quot;label&amp;quot;:null}" id="icon-button-4c1d565c-b40d-471a-a91c-c8d37024cb02" aria-labelledby="tooltip-33a1455f-d205-4aeb-82d8-ca553d989408" data-view-component="true" class="Button Button--iconOnly Button--secondary Button--medium AppHeader-button color-fg-muted"&gt;  &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-pull-request Button-visual"&gt;
&lt;path d="M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z"&gt;&lt;/path&gt;

</svg> </a><tool-tip id="tooltip-33a1455f-d205-4aeb-82d8-ca553d989408" for="icon-button-4c1d565c-b40d-471a-a91c-c8d37024cb02" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute">Your pull requests</tool-tip>

    &lt;/div&gt;

    &lt;notification-indicator data-channel="eyJjIjoibm90aWZpY2F0aW9uLWNoYW5nZWQ6MTA1MjI0OTIiLCJ0IjoxNzQxMjAwNjc1fQ==--0901f66d43c8d0ce4cd5ca93a0af6dabd04455e6ed4ab96f83841cc0cdfbce41" data-indicator-mode="none" data-tooltip-global="You have unread notifications" data-tooltip-unavailable="Notifications are unavailable at the moment." data-tooltip-none="You have no unread notifications" data-header-redesign-enabled="true" data-fetch-indicator-src="/notifications/indicator" data-fetch-indicator-enabled="true" data-view-component="true" class="js-socket-channel"&gt;
&lt;a id="AppHeader-notifications-button" href="/notifications" aria-labelledby="notification-indicator-tooltip" data-hotkey="g n" data-target="notification-indicator.link" data-analytics-event="{&amp;quot;category&amp;quot;:&amp;quot;Global navigation&amp;quot;,&amp;quot;action&amp;quot;:&amp;quot;NOTIFICATIONS_HEADER&amp;quot;,&amp;quot;label&amp;quot;:null}" data-view-component="true" class="Button Button--iconOnly Button--secondary Button--medium AppHeader-button  color-fg-muted"&gt;  &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-inbox Button-visual"&gt;
&lt;path d="M2.8 2.06A1.75 1.75 0 0 1 4.41 1h7.18c.7 0 1.333.417 1.61 1.06l2.74 6.395c.04.093.06.194.06.295v4.5A1.75 1.75 0 0 1 14.25 15H1.75A1.75 1.75 0 0 1 0 13.25v-4.5c0-.101.02-.202.06-.295Zm1.61.44a.25.25 0 0 0-.23.152L1.887 8H4.75a.75.75 0 0 1 .6.3L6.625 10h2.75l1.275-1.7a.75.75 0 0 1 .6-.3h2.863L11.82 2.652a.25.25 0 0 0-.23-.152Zm10.09 7h-2.875l-1.275 1.7a.75.75 0 0 1-.6.3h-3.5a.75.75 0 0 1-.6-.3L4.375 9.5H1.5v3.75c0 .138.112.25.25.25h12.5a.25.25 0 0 0 .25-.25Z"&gt;&lt;/path&gt;

</svg> </a>

&lt;tool-tip id="notification-indicator-tooltip" data-target="notification-indicator.tooltip" for="AppHeader-notifications-button" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute"&gt;Notifications&lt;/tool-tip&gt;

</notification-indicator>

    &lt;div class="AppHeader-user"&gt;
      &lt;deferred-side-panel data-url="/_side-panels/user?repository_id=892964695"&gt;

<include-fragment data-target="deferred-side-panel.fragment"> <react-partial-anchor

> <button data-target="react-partial-anchor.anchor" data-login="DominiqueLoyer" aria-label="Open user navigation menu" type="button" data-view-component="true" class="cursor-wait Button--invisible Button--medium Button Button--invisible-noVisuals color-bg-transparent p-0"> <span class="Button-content"> <span class="Button-label"><img src="https://avatars.githubusercontent.com/u/10522492?v=4" alt="" size="32" height="32" width="32" data-view-component="true" class="avatar circle" /></span> </span> </button> <template data-target="react-partial-anchor.template"> <script crossorigin="anonymous" defer="defer" type="application/javascript" src="https://github.githubassets.com/assets/global-user-nav-drawer-487d63bb6986.js"></script> <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/primer-react.23dd435fe36097326ec3.module.css" /> <link crossorigin="anonymous" media="all" rel="stylesheet" href="https://github.githubassets.com/assets/global-user-nav-drawer.830d6c10c9fea7fc134e.module.css" />

<react-partial partial-name="global-user-nav-drawer" data-ssr="false" data-attempted-ssr="false" >

</template> </react-partial-anchor>

</include-fragment> </deferred-side-panel> </div>

    &lt;div class="position-absolute mt-2"&gt;

<site-header-logged-in-user-menu>

</site-header-logged-in-user-menu>

    &lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;



    &lt;div class="AppHeader-localBar" &gt;
      &lt;nav data-pjax="#js-repo-pjax-container" aria-label="Repository" data-view-component="true" class="js-repo-nav js-sidenav-container-pjax js-responsive-underlinenav overflow-hidden UnderlineNav"&gt;

          &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-code UnderlineNav-octicon d-none d-sm-inline"&gt;
&lt;path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"&gt;&lt;/path&gt;

</svg> <span data-content="Code">Code</span> <span id="code-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="Not available" data-view-component="true" class="Counter"></span>

</a></li> <li data-view-component="true" class="d-inline-flex"> <a id="issues-tab" href="/Alimiji/Solr_utilisation/issues" data-tab-item="i1issues-tab" data-selected-links="repo_issues repo_labels repo_milestones /Alimiji/Solr_utilisation/issues" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g i" data-analytics-event="{"category":"Underline navbar","action":"Click tab","label":"Issues","target":"UNDERLINE_NAV.TAB"}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">

          &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-issue-opened UnderlineNav-octicon d-none d-sm-inline"&gt;
&lt;path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"&gt;&lt;/path&gt;&lt;path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z"&gt;&lt;/path&gt;

</svg> <span data-content="Issues">Issues</span> <span id="issues-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="0" hidden="hidden" data-view-component="true" class="Counter">0</span>

</a></li> <li data-view-component="true" class="d-inline-flex"> <a id="pull-requests-tab" href="/Alimiji/Solr_utilisation/pulls" data-tab-item="i2pull-requests-tab" data-selected-links="repo_pulls checks /Alimiji/Solr_utilisation/pulls" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g p" data-analytics-event="{"category":"Underline navbar","action":"Click tab","label":"Pull requests","target":"UNDERLINE_NAV.TAB"}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">

          &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-pull-request UnderlineNav-octicon d-none d-sm-inline"&gt;
&lt;path d="M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z"&gt;&lt;/path&gt;

</svg> <span data-content="Pull requests">Pull requests</span> <span id="pull-requests-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="0" hidden="hidden" data-view-component="true" class="Counter">0</span>

</a></li> <li data-view-component="true" class="d-inline-flex"> <a id="actions-tab" href="/Alimiji/Solr_utilisation/actions" data-tab-item="i3actions-tab" data-selected-links="repo_actions /Alimiji/Solr_utilisation/actions" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g a" data-analytics-event="{"category":"Underline navbar","action":"Click tab","label":"Actions","target":"UNDERLINE_NAV.TAB"}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">

          &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-play UnderlineNav-octicon d-none d-sm-inline"&gt;
&lt;path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"&gt;&lt;/path&gt;

</svg> <span data-content="Actions">Actions</span> <span id="actions-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="Not available" data-view-component="true" class="Counter"></span>

</a></li> <li data-view-component="true" class="d-inline-flex"> <a id="projects-tab" href="/Alimiji/Solr_utilisation/projects" data-tab-item="i4projects-tab" data-selected-links="repo_projects new_repo_project repo_project /Alimiji/Solr_utilisation/projects" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g b" data-analytics-event="{"category":"Underline navbar","action":"Click tab","label":"Projects","target":"UNDERLINE_NAV.TAB"}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">

          &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-table UnderlineNav-octicon d-none d-sm-inline"&gt;
&lt;path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v12.5A1.75 1.75 0 0 1 14.25 16H1.75A1.75 1.75 0 0 1 0 14.25ZM6.5 6.5v8h7.75a.25.25 0 0 0 .25-.25V6.5Zm8-1.5V1.75a.25.25 0 0 0-.25-.25H6.5V5Zm-13 1.5v7.75c0 .138.112.25.25.25H5v-8ZM5 5V1.5H1.75a.25.25 0 0 0-.25.25V5Z"&gt;&lt;/path&gt;

</svg> <span data-content="Projects">Projects</span> <span id="projects-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="0" hidden="hidden" data-view-component="true" class="Counter">0</span>

</a></li> <li data-view-component="true" class="d-inline-flex"> <a id="security-tab" href="/Alimiji/Solr_utilisation/security" data-tab-item="i5security-tab" data-selected-links="security overview alerts policy token_scanning code_scanning /Alimiji/Solr_utilisation/security" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-hotkey="g s" data-analytics-event="{"category":"Underline navbar","action":"Click tab","label":"Security","target":"UNDERLINE_NAV.TAB"}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">

          &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-shield UnderlineNav-octicon d-none d-sm-inline"&gt;
&lt;path d="M7.467.133a1.748 1.748 0 0 1 1.066 0l5.25 1.68A1.75 1.75 0 0 1 15 3.48V7c0 1.566-.32 3.182-1.303 4.682-.983 1.498-2.585 2.813-5.032 3.855a1.697 1.697 0 0 1-1.33 0c-2.447-1.042-4.049-2.357-5.032-3.855C1.32 10.182 1 8.566 1 7V3.48a1.75 1.75 0 0 1 1.217-1.667Zm.61 1.429a.25.25 0 0 0-.153 0l-5.25 1.68a.25.25 0 0 0-.174.238V7c0 1.358.275 2.666 1.057 3.86.784 1.194 2.121 2.34 4.366 3.297a.196.196 0 0 0 .154 0c2.245-.956 3.582-2.104 4.366-3.298C13.225 9.666 13.5 8.36 13.5 7V3.48a.251.251 0 0 0-.174-.237l-5.25-1.68ZM8.75 4.75v3a.75.75 0 0 1-1.5 0v-3a.75.75 0 0 1 1.5 0ZM9 10.5a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"&gt;&lt;/path&gt;

</svg> <span data-content="Security">Security</span> <include-fragment src="/Alimiji/Solr_utilisation/security/overall-count" accept="text/fragment+html"></include-fragment>

</a></li> <li data-view-component="true" class="d-inline-flex"> <a id="insights-tab" href="/Alimiji/Solr_utilisation/pulse" data-tab-item="i6insights-tab" data-selected-links="repo_graphs repo_contributors dependency_graph dependabot_updates pulse people community /Alimiji/Solr_utilisation/pulse" data-pjax="#repo-content-pjax-container" data-turbo-frame="repo-content-turbo-frame" data-analytics-event="{"category":"Underline navbar","action":"Click tab","label":"Insights","target":"UNDERLINE_NAV.TAB"}" data-view-component="true" class="UnderlineNav-item no-wrap js-responsive-underlinenav-item js-selected-navigation-item">

          &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-graph UnderlineNav-octicon d-none d-sm-inline"&gt;
&lt;path d="M1.5 1.75V13.5h13.75a.75.75 0 0 1 0 1.5H.75a.75.75 0 0 1-.75-.75V1.75a.75.75 0 0 1 1.5 0Zm14.28 2.53-5.25 5.25a.75.75 0 0 1-1.06 0L7 7.06 4.28 9.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.25-3.25a.75.75 0 0 1 1.06 0L10 7.94l4.72-4.72a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z"&gt;&lt;/path&gt;

</svg> <span data-content="Insights">Insights</span> <span id="insights-repo-tab-count" data-pjax-replace="" data-turbo-replace="" title="Not available" data-view-component="true" class="Counter"></span>

</a></li> </ul> <div style="visibility:hidden;" data-view-component="true" class="UnderlineNav-actions js-responsive-underlinenav-overflow position-absolute pr-3 pr-md-4 pr-lg-5 right-0"> <action-menu data-select-variant="none" data-view-component="true"> <focus-group direction="vertical" mnemonics retain> <button id="action-menu-d3d15682-6fb4-4fed-b1e8-408eb58ef984-button" popovertarget="action-menu-d3d15682-6fb4-4fed-b1e8-408eb58ef984-overlay" aria-controls="action-menu-d3d15682-6fb4-4fed-b1e8-408eb58ef984-list" aria-haspopup="true" aria-labelledby="tooltip-dadfd319-a6a7-4026-ba2c-925ac8df240a" type="button" data-view-component="true" class="Button Button--iconOnly Button--secondary Button--medium UnderlineNav-item"> <svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-kebab-horizontal Button-visual"> <path d="M8 9a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3ZM1.5 9a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Zm13 0a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"></path> </svg> </button><tool-tip id="tooltip-dadfd319-a6a7-4026-ba2c-925ac8df240a" for="action-menu-d3d15682-6fb4-4fed-b1e8-408eb58ef984-button" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute">Additional navigation options</tool-tip>

<anchored-position data-target="action-menu.overlay" id="action-menu-d3d15682-6fb4-4fed-b1e8-408eb58ef984-overlay" anchor="action-menu-d3d15682-6fb4-4fed-b1e8-408eb58ef984-button" align="start" side="outside-bottom" anchor-offset="normal" popover="auto" data-view-component="true"> <div data-view-component="true" class="Overlay Overlay--size-auto">

  &lt;div data-view-component="true" class="Overlay-body Overlay-body--paddingNone"&gt;          &lt;action-list&gt;

&lt;a tabindex="-1" id="item-447cc7aa-1f1d-473b-8b22-dd49e5fdb4eb" href="/Alimiji/Solr_utilisation" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-code"&gt;
&lt;path d="m11.28 3.22 4.25 4.25a.75.75 0 0 1 0 1.06l-4.25 4.25a.749.749 0 0 1-1.275-.326.749.749 0 0 1 .215-.734L13.94 8l-3.72-3.72a.749.749 0 0 1 .326-1.275.749.749 0 0 1 .734.215Zm-6.56 0a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042L2.06 8l3.72 3.72a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L.47 8.53a.75.75 0 0 1 0-1.06Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Code

</span>
</a>

</li> <li hidden="hidden" data-menu-item="i1issues-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">

&lt;a tabindex="-1" id="item-6ce50039-f514-4487-9611-7e50fc0a2770" href="/Alimiji/Solr_utilisation/issues" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-issue-opened"&gt;
&lt;path d="M8 9.5a1.5 1.5 0 1 0 0-3 1.5 1.5 0 0 0 0 3Z"&gt;&lt;/path&gt;&lt;path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Issues

</span>
</a>

</li> <li hidden="hidden" data-menu-item="i2pull-requests-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">

&lt;a tabindex="-1" id="item-5331a6e8-a343-487c-86ce-cabff242c988" href="/Alimiji/Solr_utilisation/pulls" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-git-pull-request"&gt;
&lt;path d="M1.5 3.25a2.25 2.25 0 1 1 3 2.122v5.256a2.251 2.251 0 1 1-1.5 0V5.372A2.25 2.25 0 0 1 1.5 3.25Zm5.677-.177L9.573.677A.25.25 0 0 1 10 .854V2.5h1A2.5 2.5 0 0 1 13.5 5v5.628a2.251 2.251 0 1 1-1.5 0V5a1 1 0 0 0-1-1h-1v1.646a.25.25 0 0 1-.427.177L7.177 3.427a.25.25 0 0 1 0-.354ZM3.75 2.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm0 9.5a.75.75 0 1 0 0 1.5.75.75 0 0 0 0-1.5Zm8.25.75a.75.75 0 1 0 1.5 0 .75.75 0 0 0-1.5 0Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Pull requests

</span>
</a>

</li> <li hidden="hidden" data-menu-item="i3actions-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">

&lt;a tabindex="-1" id="item-e4b375d2-3534-4e26-a709-1a89e4dce0a4" href="/Alimiji/Solr_utilisation/actions" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-play"&gt;
&lt;path d="M8 0a8 8 0 1 1 0 16A8 8 0 0 1 8 0ZM1.5 8a6.5 6.5 0 1 0 13 0 6.5 6.5 0 0 0-13 0Zm4.879-2.773 4.264 2.559a.25.25 0 0 1 0 .428l-4.264 2.559A.25.25 0 0 1 6 10.559V5.442a.25.25 0 0 1 .379-.215Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Actions

</span>
</a>

</li> <li hidden="hidden" data-menu-item="i4projects-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">

&lt;a tabindex="-1" id="item-2c57d4d6-8b45-47d6-b1b1-ccea2b3d0551" href="/Alimiji/Solr_utilisation/projects" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-table"&gt;
&lt;path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v12.5A1.75 1.75 0 0 1 14.25 16H1.75A1.75 1.75 0 0 1 0 14.25ZM6.5 6.5v8h7.75a.25.25 0 0 0 .25-.25V6.5Zm8-1.5V1.75a.25.25 0 0 0-.25-.25H6.5V5Zm-13 1.5v7.75c0 .138.112.25.25.25H5v-8ZM5 5V1.5H1.75a.25.25 0 0 0-.25.25V5Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Projects

</span>
</a>

</li> <li hidden="hidden" data-menu-item="i5security-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">

&lt;a tabindex="-1" id="item-7103d367-6e5a-4d9d-87ba-d22662d6b88c" href="/Alimiji/Solr_utilisation/security" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-shield"&gt;
&lt;path d="M7.467.133a1.748 1.748 0 0 1 1.066 0l5.25 1.68A1.75 1.75 0 0 1 15 3.48V7c0 1.566-.32 3.182-1.303 4.682-.983 1.498-2.585 2.813-5.032 3.855a1.697 1.697 0 0 1-1.33 0c-2.447-1.042-4.049-2.357-5.032-3.855C1.32 10.182 1 8.566 1 7V3.48a1.75 1.75 0 0 1 1.217-1.667Zm.61 1.429a.25.25 0 0 0-.153 0l-5.25 1.68a.25.25 0 0 0-.174.238V7c0 1.358.275 2.666 1.057 3.86.784 1.194 2.121 2.34 4.366 3.297a.196.196 0 0 0 .154 0c2.245-.956 3.582-2.104 4.366-3.298C13.225 9.666 13.5 8.36 13.5 7V3.48a.251.251 0 0 0-.174-.237l-5.25-1.68ZM8.75 4.75v3a.75.75 0 0 1-1.5 0v-3a.75.75 0 0 1 1.5 0ZM9 10.5a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Security

</span>
</a>

</li> <li hidden="hidden" data-menu-item="i6insights-tab" data-targets="action-list.items" role="none" data-view-component="true" class="ActionListItem">

&lt;a tabindex="-1" id="item-f9ba8c15-48f3-4c6b-ad7a-49339f0de79b" href="/Alimiji/Solr_utilisation/pulse" role="menuitem" data-view-component="true" class="ActionListContent ActionListContent--visual16"&gt;
    &lt;span class="ActionListItem-visual ActionListItem-visual--leading"&gt;
      &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-graph"&gt;
&lt;path d="M1.5 1.75V13.5h13.75a.75.75 0 0 1 0 1.5H.75a.75.75 0 0 1-.75-.75V1.75a.75.75 0 0 1 1.5 0Zm14.28 2.53-5.25 5.25a.75.75 0 0 1-1.06 0L7 7.06 4.28 9.78a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042l3.25-3.25a.75.75 0 0 1 1.06 0L10 7.94l4.72-4.72a.751.751 0 0 1 1.042.018.751.751 0 0 1 .018 1.042Z"&gt;&lt;/path&gt;

</svg> </span>

    &lt;span data-view-component="true" class="ActionListItem-label"&gt;
      Insights

</span>
</a>

</li> </ul>
</div></action-list>

</div>

</div></anchored-position> </focus-group> </action-menu></div> </nav> </div> </header>

  &lt;div hidden="hidden" data-view-component="true" class="js-stale-session-flash stale-session-flash flash flash-warn flash-full"&gt;

    &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-alert"&gt;
&lt;path d="M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"&gt;&lt;/path&gt;

</svg> <span class="js-stale-session-flash-signed-in" hidden>You signed in with another tab or window. <a class="Link--inTextBlock" href="">Reload</a> to refresh your session.</span> <span class="js-stale-session-flash-signed-out" hidden>You signed out in another tab or window. <a class="Link--inTextBlock" href="">Reload</a> to refresh your session.</span> <span class="js-stale-session-flash-switched" hidden>You switched accounts on another tab or window. <a class="Link--inTextBlock" href="">Reload</a> to refresh your session.</span>

&lt;button id="icon-button-e0c8af87-0725-484e-a33e-7b75baf9efdc" aria-labelledby="tooltip-46b6559d-b6fb-476c-b0f4-18aa3691ae5c" type="button" data-view-component="true" class="Button Button--iconOnly Button--invisible Button--medium flash-close js-flash-close"&gt;  &lt;svg aria-hidden="true" height="16" viewBox="0 0 16 16" version="1.1" width="16" data-view-component="true" class="octicon octicon-x Button-visual"&gt;
&lt;path d="M3.72 3.72a.75.75 0 0 1 1.06 0L8 6.94l3.22-3.22a.749.749 0 0 1 1.275.326.749.749 0 0 1-.215.734L9.06 8l3.22 3.22a.749.749 0 0 1-.326 1.275.749.749 0 0 1-.734-.215L8 9.06l-3.22 3.22a.751.751 0 0 1-1.042-.018.751.751 0 0 1-.018-1.042L6.94 8 3.72 4.78a.75.75 0 0 1 0-1.06Z"&gt;&lt;/path&gt;

</svg> </button><tool-tip id="tooltip-46b6559d-b6fb-476c-b0f4-18aa3691ae5c" for="icon-button-e0c8af87-0725-484e-a33e-7b75baf9efdc" popover="manual" data-direction="s" data-type="label" data-view-component="true" class="sr-only position-absolute">Dismiss alert</tool-tip>

</div>

&lt;/div&gt;

&lt;div id="js-flash-container" class="flash-container" data-turbo-replace&gt;

  &lt;div&gt;{{ message }}&lt;/div&gt;

&lt;/div&gt;

</div> </div> </template> </div>

<notification-shelf-watcher data-base-url="https://github.com/notifications/beta/shelf" data-channel="eyJjIjoibm90aWZpY2F0aW9uLWNoYW5nZWQ6MTA1MjI0OTIiLCJ0IjoxNzQxMjAwNjc1fQ==--0901f66d43c8d0ce4cd5ca93a0af6dabd04455e6ed4ab96f83841cc0cdfbce41" data-view-component="true" class="js-socket-channel"></notification-shelf-watcher> <div hidden data-initial data-target="notification-shelf-watcher.placeholder"></div>

<turbo-frame id="repo-content-turbo-frame" target="_top" data-turbo-action="advance" class=""> <div id="repo-content-pjax-container" class="repository-content " > <a href="https://github.dev/" class="d-none js-github-dev-shortcut" data-hotkey=".,Mod+Alt+.">Open in github.dev</a> <a href="https://github.dev/" class="d-none js-github-dev-new-tab-shortcut" data-hotkey="Shift+.,Shift+>,>" target="_blank" rel="noopener noreferrer">Open in a new github.dev tab</a> <a class="d-none" data-hotkey=",,Mod+Alt+," target="_blank" href="/codespaces/new/Alimiji/Solr_utilisation/tree/main?resume=1">Open in codespace</a>

<react-app app-name="react-code-view" initial-path="/Alimiji/Solr_utilisation/blob/main/extraire_fichiers.py" style="display: block; min-height: calc(100vh - 64px);" data-attempted-ssr="true" data-ssr="true" data-lazy="false" data-alternate="false" data-data-router-enabled="false" >

Uh oh!

DominiqueLoyer/DominiqueLoyer.github.io

About

Topics

Resources

Security policy

Uh oh!

Stars

Watchers

Forks

Sponsor this project

Uh oh!

Uh oh!

Contributors 2

Uh oh!

Languages