import wmi
import locale
import tkinter as tk
from tkinter import ttk
import threading
 
# Initialize WMI
strComputer = "localhost"
objWMIService = wmi.WMI(computer=strComputer)
 
# Language detection
os_lang = locale.getdefaultlocale()[0]
if os_lang in ["fr_FR", "fr_BE", "fr_CA", "fr_CH", "fr_LU", "fr_MC"]:
    SLANGUE = "Francais"
else:
    SLANGUE = "Anglais"
 
# Language-specific strings
labels = {}
 
# Generic function to get WMI data
def get_wmi_data(wmi_class):
    try:
        wmi_objects = objWMIService.instancesOf(wmi_class)
        return wmi_objects
    except Exception as e:
        print(f"Error getting {wmi_class}: {e}")
        return []
 
# WMI Functions
def OperatingSystem():
    Output = ""
    colItems = objWMIService.Win32_OperatingSystem()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_OperatingSystem\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"{labels.get('Name', 'Name')}: {objItem.Name}\n"
            Output += f"OS Architecture : {objItem.OSArchitecture}\n"
            Output += f"{labels.get('Manufacturer', 'Manufacturer')}: {objItem.Manufacturer}\n"
 
            # Check if MUILanguages is not None and not empty
            if objItem.MUILanguages:
                Output += f"MUI Languages : {objItem.MUILanguages[0]}\n"
            else:
                Output += "MUI Languages : N/A\n"
 
            Output += f"Version : {objItem.Version}\n"
            Output += f"SystemDrive : {objItem.SystemDrive}\n"
            Output += f"Build Number : {objItem.BuildNumber}\n"  # Numéro de build
            Output += f"Registered User : {objItem.RegisteredUser}\n"  # Utilisateur enregistré
            Output += f"SerialNumber : {objItem.SerialNumber}\n"  # Numéro de série
            Output += "-----------------------------------------\n\n"
 
            # Free memory info
            FPMem = int(objItem.FreePhysicalMemory) / (1024 ** 2)
            ResutFreePhyMem = f"{FPMem:.2f}"
            Output += f"{labels.get('FreePhysicalMemory', 'FreePhysicalMemory')}: {ResutFreePhyMem} - GO\n"
 
            FSpacePF = int(objItem.FreeSpaceInPagingFiles) / (1024 ** 2)
            ResultFreeSpacePF = f"{FSpacePF:.2f}"
            Output += f"{labels.get('FreeSpaceInPagingFiles', 'FreeSpaceInPagingFiles')}: {ResultFreeSpacePF} - GO\n"
 
            FreeVirtualMem = int(objItem.FreeVirtualMemory) / (1024 ** 2)
            ResultFreeVirtualMem = f"{FreeVirtualMem:.2f}"
            Output += f"{labels.get('FreeVirtualMemory', 'FreeVirtualMemory')}: {ResultFreeVirtualMem} - GO\n"
 
            Output += "-----------------------------------------\n\n"
            Output += f"{labels.get('NumberOfLicensedUsers', 'NumberOfLicensedUsers')}: {objItem.NumberOfLicensedUsers}\n"
            Output += f"{labels.get('NumberOfProcesses', 'NumberOfProcesses')}: {objItem.NumberOfProcesses}\n"
            Output += f"{labels.get('NumberOfUsers', 'NumberOfUsers')}: {objItem.NumberOfUsers}\n"
            Output += f"Total Visible Memory Size: {objItem.TotalVisibleMemorySize} KB\n"  # Taille mémoire totale visible
            Output += f"Install Date: {objItem.InstallDate}\n"  # Date d'installation
 
    if not Output:
        Output += f"{labels.get('SortieWMI_OperatingSystem', 'No Operating System Information')}\n"
 
    return Output
 
def BIOS():
    Output = ""
    colItems = objWMIService.Win32_BIOS()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_BIOS\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"{labels.get('Name', 'Name')}: {objItem.Name}\n"
            Output += f"{labels.get('Manufacturer', 'Manufacturer')}: {objItem.Manufacturer}\n"
            Output += f"{labels.get('Version', 'Version')}: {objItem.SMBIOSBIOSVersion}\n"
            Output += f"{labels.get('SerialNumber', 'SerialNumber')}: {objItem.SerialNumber}\n"
            Output += f"Release Date: {objItem.ReleaseDate}\n"  # Date de sortie du BIOS
            Output += f"BIOS Version: {objItem.Version}\n"  # Version du BIOS
            Output += f"Build Number: {objItem.BuildNumber}\n"  # Numéro de build
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Bios', 'No BIOS Information')}\n"
    return Output
 
def BaseBoard():
    Output = ""
    colItems = objWMIService.Win32_BaseBoard()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_BaseBoard\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"{labels.get('Manufacturer', 'Manufacturer')}: {objItem.Manufacturer}\n"
            Output += f"{labels.get('Product', 'Product')}: {objItem.Product}\n"
            Output += f"{labels.get('Version', 'Version')}: {objItem.Version}\n"
            Output += f"{labels.get('SerialNumber', 'SerialNumber')}: {objItem.SerialNumber}\n"
            Output += f"Hosting Board: {objItem.HostingBoard}\n"  # Indique si c'est une carte d'accueil
            Output += f"Hot Swappable: {objItem.HotSwappable}\n"  # Indique si elle est remplaçable à chaud
            Output += f"Removable: {objItem.Removable}\n"  # Indique si elle est amovible
            Output += f"Replaceable: {objItem.Replaceable}\n"  # Indique si elle est remplaçable
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_BaseBoard', 'No Base Board Information')}\n"
    return Output
 
def Processor():
    Output = ""
    colItems = objWMIService.Win32_Processor()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_Processor\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"{labels.get('Name', 'Name')}: {objItem.Name}\n"
            Output += f"{labels.get('Manufacturer', 'Manufacturer')}: {objItem.Manufacturer}\n"
            Output += f"{labels.get('Caption', 'Caption')}: {objItem.Caption}\n"
            Output += f"{labels.get('DeviceID', 'DeviceID')}: {objItem.DeviceID}\n"
 
            Output += f"Architecture: {objItem.Architecture}\n"
            Output += f"Current Clock Speed: {objItem.CurrentClockSpeed}\n"
            Output += f"Max Clock Speed: {objItem.MaxClockSpeed}\n"
            Output += f"Number of Cores: {objItem.NumberOfCores}\n"
            Output += f"Number of Logical Processors: {objItem.NumberOfLogicalProcessors}\n"
            Output += f"L2 Cache Size: {objItem.L2CacheSize}\n"
            Output += f"L3 Cache Size: {objItem.L3CacheSize}\n"
            Output += f"Data Width: {objItem.DataWidth}\n"
            Output += f"Description: {objItem.Description}\n"
            Output += f"Family: {objItem.Family}\n"
            Output += f"ProcessorId: {objItem.ProcessorId}\n"
            Output += f"Revision: {objItem.Revision}\n"
            Output += f"Role: {objItem.Role}\n"
            Output += f"UpgradeMethod: {objItem.UpgradeMethod}\n"
            Output += f"VoltageCaps: {objItem.VoltageCaps}\n"
            Output += f"Current Voltage: {objItem.CurrentVoltage}\n" # Tension actuelle
            Output += f"ExtClock: {objItem.ExtClock}\n" # Horloge externe
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Processor', 'No Processor Information')}\n"
    return Output
 
def PhysicalMemory():
    Output = ""
    colItems = objWMIService.Win32_PhysicalMemory()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_PhysicalMemory\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"{labels.get('Capacity', 'Capacity')}: {objItem.Capacity}\n"
            Output += f"{labels.get('Speed', 'Speed')}: {objItem.Speed}\n"
            Output += f"{labels.get('Manufacturer', 'Manufacturer')}: {objItem.Manufacturer}\n"
            Output += f"Device Locator: {objItem.DeviceLocator}\n"  # Emplacement du périphérique
            Output += f"Form Factor: {objItem.FormFactor}\n"  # Facteur de forme
            Output += f"Part Number: {objItem.PartNumber}\n"  # Numéro de pièce
            Output += f"Serial Number: {objItem.SerialNumber}\n"  # Numéro de série
            Output += f"SMBIOS Memory Type: {objItem.SMBIOSMemoryType}\n"  # Type de mémoire
            Output += f"Tag: {objItem.Tag}\n"  # Tag
            Output += f"Total Width: {objItem.TotalWidth}\n"  # Largeur totale
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_PhysicalMemory', 'No Physical Memory Information')}\n"
    return Output
 
def VideoController():
    Output = ""
    colItems = objWMIService.Win32_VideoController()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_VideoController\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"{labels.get('Name', 'Name')}: {objItem.Name}\n"
            Output += f"{labels.get('AdapterRAM', 'AdapterRAM')}: {objItem.AdapterRAM}\n"
            Output += f"{labels.get('CurrentBitsPerPixel', 'CurrentBitsPerPixel')}: {objItem.CurrentBitsPerPixel}\n"
            Output += f"{labels.get('CurrentRefreshRate', 'CurrentRefreshRate')}: {objItem.CurrentRefreshRate}\n"
            Output += f"Adapter DAC Type: {objItem.AdapterDACType}\n"  # Type de DAC
            Output += f"Driver Version: {objItem.DriverVersion}\n"  # Version du pilote
            Output += f"Video Mode Description: {objItem.VideoModeDescription}\n"  # Description du mode vidéo
            Output += f"Video Processor: {objItem.VideoProcessor}\n"  # Processeur vidéo
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_VideoController', 'No Video Controller Information')}\n"
    return Output
 
def DiskDrive():
    Output = ""
    colItems = objWMIService.Win32_DiskDrive()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_DiskDrive\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Model: {objItem.Model}\n"
            Output += f"Size: {objItem.Size}\n"
            Output += f"InterfaceType: {objItem.InterfaceType}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_DiskDrive', 'No Disk Drive Information')}\n"
    return Output
 
def NetworkAdapter():
    Output = ""
    colItems = objWMIService.Win32_NetworkAdapter()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_NetworkAdapter\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Name: {objItem.Name}\n"
            Output += f"MACAddress: {objItem.MACAddress}\n"
            Output += f"AdapterType: {objItem.AdapterType}\n"
            Output += f"NetConnectionID: {objItem.NetConnectionID}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_NetworkAdapter', 'No Network Adapter Information')}\n"
    return Output
 
def ComputerSystem():
    Output = ""
    colItems = objWMIService.Win32_ComputerSystem()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_ComputerSystem\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Model: {objItem.Model}\n"
            Output += f"Manufacturer: {objItem.Manufacturer}\n"
            Output += f"TotalPhysicalMemory: {objItem.TotalPhysicalMemory}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_ComputerSystem', 'No Computer System Information')}\n"
    return Output
 
def ProcessInfo():
    Output = ""
    colItems = objWMIService.Win32_Process()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_Process\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Name: {objItem.Name}\n"
            Output += f"ProcessId: {objItem.ProcessId}\n"
            Output += f"ExecutablePath: {objItem.ExecutablePath}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Process', 'No Process Information')}\n"
    return Output
 
def BatteryInfo():
    Output = ""
    colItems = objWMIService.Win32_Battery()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_Battery\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"DesignCapacity: {objItem.DesignCapacity}\n"
            Output += f"EstimatedChargeRemaining: {objItem.EstimatedChargeRemaining}\n"
            Output += f"BatteryStatus: {objItem.BatteryStatus}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Battery', 'No Battery Information')}\n"
    return Output
 
def FanInfo():
    Output = ""
    colItems = objWMIService.Win32_Fan()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_Fan\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Name: {objItem.Name}\n"
            Output += f"Status: {objItem.Status}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Fan', 'No Fan Information')}\n"
    return Output
 
def NetworkAdapterConfiguration():
    Output = ""
    colItems = objWMIService.Win32_NetworkAdapterConfiguration()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_NetworkAdapterConfiguration\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            if objItem.IPAddress:
                Output += f"IPAddress: {objItem.IPAddress[0]}\n"
            if objItem.DefaultIPGateway:
                Output += f"DefaultIPGateway: {objItem.DefaultIPGateway[0]}\n"
            if objItem.DNSServerSearchOrder:
                Output += f"DNSServerSearchOrder: {objItem.DNSServerSearchOrder}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_NetworkAdapterConfiguration', 'No Network Adapter Configuration Information')}\n"
    return Output
 
def KeyboardInfo():
    Output = ""
    colItems = objWMIService.Win32_Keyboard()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_Keyboard\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Description: {objItem.Description}\n"
            Output += f"Manufacturer: {objItem.Manufacturer}\n"
            Output += f"Name: {objItem.Name}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Keyboard', 'No Keyboard Information')}\n"
    return Output
 
def PrinterInfo():
    Output = ""
    colItems = objWMIService.Win32_Printer()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_Printer\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Name: {objItem.Name}\n"
            Output += f"PortName: {objItem.PortName}\n"
            Output += f"DriverName: {objItem.DriverName}\n"
            Output += f"PrinterStatus: {objItem.PrinterStatus}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Printer', 'No Printer Information')}\n"
    return Output
 
def PowerManagementEvent():
    Output = ""
    colItems = objWMIService.Win32_PowerManagementEvent()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_PowerManagementEvent\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"EventType: {objItem.EventType}\n"
            Output += f"EventTypeName: {objItem.EventTypeName}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_PowerManagementEvent', 'No Power Management Event Information')}\n"
    return Output
 
def SoftwareFeature():
    Output = ""
    colItems = objWMIService.Win32_SoftwareFeature()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_SoftwareFeature\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Name: {objItem.Name}\n"
            Output += f"Description: {objItem.Description}\n"
            Output += f"InstallDate: {objItem.InstallDate}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_SoftwareFeature', 'No Software Feature Information')}\n"
    return Output
 
def StartupCommand():
    Output = ""
    colItems = objWMIService.Win32_StartupCommand()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_StartupCommand\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Name: {objItem.Name}\n"
            Output += f"Command: {objItem.Command}\n"
            Output += f"Location: {objItem.Location}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_StartupCommand', 'No Startup Command Information')}\n"
    return Output
 
def ServiceInfo():
    Output = ""
    colItems = objWMIService.Win32_Service()
 
    if colItems:
        Output += f"{labels.get('SWMI', 'WMI Output')} Win32_Service\n"
        Output += "-----------------------------------------\n\n"
 
        for objItem in colItems:
            Output += f"Name: {objItem.Name}\n"
            Output += f"DisplayName: {objItem.DisplayName}\n"
            Output += f"State: {objItem.State}\n"
            Output += f"StartMode: {objItem.StartMode}\n"
        Output += "-----------------------------------------\n\n"
    else:
        Output += f"{labels.get('SortieWMI_Service', 'No Service Information')}\n"
    return Output
 
# Function to display WMI data in the text widget
def display_wmi_data(wmi_function):
    result_text.config(state=tk.NORMAL)
    result_text.delete("1.0", tk.END)
 
    output = wmi_function()
    result_text.insert(tk.END, output)
 
    result_text.config(state=tk.DISABLED)
 
# Interface graphique
root = tk.Tk()
root.title("WMI Data Viewer")
 
# Style personnalisé pour les boutons
style = ttk.Style()
style.theme_use('clam')
style.configure(
    "Custom.TButton",
    font=("Segoe UI", 12, "bold"),
    foreground="white",
    background="#007ACC",
    padding=5
)
style.map(
    "Custom.TButton",
    foreground=[('pressed', 'yellow'), ('active', 'white')],
    background=[('pressed', '#005F8C'), ('active', '#3399FF')]
)
 
# Panneau de choix à gauche
choice_frame = ttk.Frame(root, padding=10)
choice_frame.pack(side=tk.LEFT, fill=tk.Y)
 
# Buttons to display information
ttk.Button(choice_frame, text="Operating System", style="Custom.TButton",
           command=lambda: display_wmi_data(OperatingSystem)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="BIOS", style="Custom.TButton",
           command=lambda: display_wmi_data(BIOS)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="BaseBoard", style="Custom.TButton",
           command=lambda: display_wmi_data(BaseBoard)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="Processor", style="Custom.TButton",
           command=lambda: display_wmi_data(Processor)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="PhysicalMemory", style="Custom.TButton",
           command=lambda: display_wmi_data(PhysicalMemory)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="VideoController", style="Custom.TButton",
           command=lambda: display_wmi_data(VideoController)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="DiskDrive", style="Custom.TButton",
           command=lambda: display_wmi_data(DiskDrive)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="NetworkAdapter", style="Custom.TButton",
           command=lambda: display_wmi_data(NetworkAdapter)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="ComputerSystem", style="Custom.TButton",
           command=lambda: display_wmi_data(ComputerSystem)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="ProcessInfo", style="Custom.TButton",
           command=lambda: display_wmi_data(ProcessInfo)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="BatteryInfo", style="Custom.TButton",
           command=lambda: display_wmi_data(BatteryInfo)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="FanInfo", style="Custom.TButton",
           command=lambda: display_wmi_data(FanInfo)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="NetworkAdapterConfiguration", style="Custom.TButton",
           command=lambda: display_wmi_data(NetworkAdapterConfiguration)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="KeyboardInfo", style="Custom.TButton",
           command=lambda: display_wmi_data(KeyboardInfo)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="PrinterInfo", style="Custom.TButton",
           command=lambda: display_wmi_data(PrinterInfo)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="PowerManagementEvent", style="Custom.TButton",
           command=lambda: display_wmi_data(PowerManagementEvent)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="SoftwareFeature", style="Custom.TButton",
           command=lambda: display_wmi_data(SoftwareFeature)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="StartupCommand", style="Custom.TButton",
           command=lambda: display_wmi_data(StartupCommand)).pack(pady=5, padx=5, fill=tk.X)
ttk.Button(choice_frame, text="ServiceInfo", style="Custom.TButton",
           command=lambda: display_wmi_data(ServiceInfo)).pack(pady=5, padx=5, fill=tk.X)
 
# Panneau d'affichage des résultats à droite
result_frame = ttk.Frame(root, padding=10)
result_frame.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
 
# Scrollbar à droite
scrollbar = ttk.Scrollbar(result_frame)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
 
# Zone de texte pour les résultats
result_text = tk.Text(result_frame, wrap=tk.WORD, state=tk.DISABLED, yscrollcommand=scrollbar.set)
result_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
 
# Configuration du scrollbar
scrollbar.config(command=result_text.yview)
 
root.mainloop()