Python Program exe yapılınca terminal siyah ekranda kalıyor

import sys
import subprocess
from PyQt5.QtWidgets import QListWidget
from PyQt5.QtWidgets import QApplication
from PyQt5.QtWidgets import QMainWindow
from PyQt5.QtWidgets import QTabWidget
from PyQt5.QtWidgets import QWidget
from PyQt5.QtWidgets import QVBoxLayout
from PyQt5.QtWidgets import QLabel
from PyQt5.QtWidgets import QCheckBox
from PyQt5.QtWidgets import QPushButton
from PyQt5.QtWidgets import QScrollArea
from PyQt5.QtWidgets import QTextEdit
from PyQt5.QtWidgets import QMessageBox
from PyQt5.QtWidgets import QAction
from PyQt5.QtCore import Qt
import qdarkstyle
import os
import ctypes
import winreg
import psutil
import cpuinfo
import platform
import pyopencl as cl

program_dir = os.path.dirname(os.path.abspath(__file__))
tweakler_dir = os.path.join(program_dir, "Tweakler KURCALAMA")
redistler_dir = os.path.join(program_dir, "redistler")

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Program Yöneticisi")
        self.setGeometry(100, 100, 750, 600)
        self.tab_widget =QTabWidget()
        self.apply_dark_theme()
        self.setCentralWidget(self.tab_widget)
        self.create_menu()
        
        tabs = [("Programlar", self.add_programs_tab),
                ("Tweakler", self.add_tweaks_tab),
                ("Güncelleştirmeler", self.add_updates_tab),
                ("Program Kaldırma", self.add_uninstall_tab),
                ("Hakkında", self.add_about_tab),
                ("Sistem Bilgileri", self.add_system_info_tab)
            ]
        for title, method in tabs:
            self.add_tab(title, method)
            
    def add_tab(self, title, add_content_method):
        tab = QWidget()
        self.tab_widget.addTab(tab, title)
        add_content_method(tab)
    
    
    def add_programs_tab(self, tab):
        layout = QVBoxLayout()
        programs_list = [
            "Discord", "Steam", "Afterburner", "Google Drive", "Notebook-FanControl", "BlueStacks",
            "Visual Studio programlari -Hepsi bir arada- (Oyunlar icin)", "FxSound",
            "Lively Wallpaper", "Winrar", "Vlc Media Player",
            "Spacedesk Windows Driver", "Nvidia Gaming Experience", "Whatsapp", "MS Zoom", "Opera GX Browser",
            "Spotify", "Apple iTunes", "Deezer", "Youtube Music Desktop", "Epic Games", "Skype",
            "Adobe Acrobat (64bit)", "Yandex Disk", "LibreOffice", "LOL EUW", "Chrome", "Cloudflare WARP",
            "7Zip", "AIDA 64 Extreme", "Recuva", "Rufus", "Brave Browser", "Teamwiever", "QTorrent", "CCleaner"
            ]


        scroll_area = QScrollArea()
        scroll_widget = QWidget()
        scroll_layout = QVBoxLayout()

        # Yeni bir QTextEdit oluşturarak log penceresi ekleniyor
        self.log_text = QTextEdit()
        self.log_text.setReadOnly(True)  # Kullanıcı tarafından düzenlenemez yapılıyor


        checkboxes = []
        for program in programs_list:
            checkbox = QCheckBox(program)
            checkboxes.append(checkbox)
            scroll_layout.addWidget(checkbox)

        scroll_widget.setLayout(scroll_layout)
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(scroll_widget)

        kur_button = QPushButton("Kur")
        kur_button.clicked.connect(lambda: self.install_programs(checkboxes))

        # Yeni bir layout oluşturuluyor ve içine scroll alanı, log penceresi ve kurma butonu ekleniyor
        final_layout = QVBoxLayout()
        final_layout.addWidget(scroll_area)
        final_layout.addWidget(self.log_text)  # Log penceresi ekleniyor
        final_layout.addWidget(kur_button, 0, alignment=Qt.Alignment(0x84))  # alignment = Qt.AlignRight | Qt.AlignTop

        tab.setLayout(final_layout)

        scroll_area = QScrollArea()
        scroll_widget = QWidget()
        scroll_layout = QVBoxLayout()
    def add_tweaks_tab(self, tab):
        layout = QVBoxLayout()
        tweaks_list = [
            "UWT 5.1 (Ultimate Windows Tweaker 5.1)",
            "Chocolatey",
            "DNS Jumper",
            "BloatyNosy",
            "Linus Titus Uzman Ayarlari",
            "Sağ Tık Güç Seceneklerini Ayarlama Özelliği Ekleme",
            "Sağ Tık Güç Seçeneklerini Ayarlama Özelliği İptali",
            "Güç Seçeneklerine CPU Frekansı Ayarı Getirme/Kaldırma",
            "Msi Utility V3",
            "SSD Booster",
            "Optimizer"
            # Diğer tweakler buraya eklenebilir
        ]

        scroll_area = QScrollArea()
        scroll_widget = QWidget()
        scroll_layout = QVBoxLayout()

        checkboxes = []
        for tweak in tweaks_list:
            checkbox = QCheckBox(tweak)
            checkboxes.append(checkbox)
            scroll_layout.addWidget(checkbox)

        scroll_widget.setLayout(scroll_layout)
        scroll_area.setWidgetResizable(True)
        scroll_area.setWidget(scroll_widget)

        apply_button = QPushButton("Uygula")
        apply_button.clicked.connect(lambda: self.apply_tweaks(checkboxes))

        layout.addWidget(scroll_area)
        layout.addWidget(apply_button, alignment=Qt.Alignment(0x84))

        tab.setLayout(layout)
    def apply_tweaks(self, checkboxes):
        selected_tweaks = [checkbox.text() for checkbox in checkboxes if checkbox.isChecked()]
        for tweak in selected_tweaks:
            if tweak == "UWT 5.1 (Ultimate Windows Tweaker 5.1)":
                uwt_path = os.path.join(tweakler_dir, "uwt5.1.exe")
                os.startfile(uwt_path)
            elif tweak == "SSD Booster":
                ssd_path = os.path.join(tweakler_dir,"ssdbooster.exe")
                os.startfile(ssd_path)
            elif tweak == "Optimizer":
                optimizer_path =os.path.join(tweakler_dir,"optimizer.exe")
                os.startfile(optimizer_path)
            elif tweak == "Msi Utility V3":
                util_path = os.path.join(tweakler_dir,"msiutil.exe")
                ctypes.windll.shell32.ShellExecuteW(None, "runas", util_path, None, None, 1)
            elif tweak == "Chocolatey":
                subprocess.run(["powershell", "-Command", "Set-ExecutionPolicy", "Bypass", "-Scope", "Process", "-Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))"])
                self.log_text.append("Chocolatey tweak uygulandı")
            elif tweak == "BloatyNosy":
                bloatnosy_path = os.path.join(tweakler_dir, "bloatnosy.exe")
                os.startfile(bloatnosy_path)
            elif tweak == "DNS Jumper":
                dnsjumper_path = os.path.join(tweakler_dir, "dnsjumper.exe")
                os.startfile(dnsjumper_path)
            elif tweak == "Linus Titus Uzman Ayarlari":
                subprocess.run(["powershell", "-ExecutionPolicy", "Bypass", "-Command", "Invoke-WebRequest -Uri 'https://christitus.com/win' | Invoke-Expression"])
                self.log_text.append("Linus Titus Uzman Ayarlari tweak uygulandı")
            elif tweak == "Sağ Tık Güç Seceneklerini Ayarlama Özelliği Ekleme":
                registry_path = os.path.join(tweakler_dir, "sagtikguc.reg")
                os.startfile(registry_path)
                self.log_text.append("Sağ Tık Güç Seceneklerini Ayarlama Özelliği Ekleme tweak'i uygulandı")
            elif tweak == "Sağ Tık Güç Seceneklerini Ayarlama Özelliği İptali":
                registry_cancel_path = os.path.join(tweakler_dir, "sagtikguciptal.reg")
                os.startfile(registry_cancel_path)
                self.log_text.append("Sağ Tık Güç Seceneklerini Ayarlama Özelliği İptali tweak'i uygulandı")
            elif tweak == "Güç Seçeneklerine CPU Frekansı Ayarı Getirme/Kaldırma":
                frequency_path = os.path.join(tweakler_dir, "cpufrekansaktifdeaktif.vbe")
                os.startfile(frequency_path)
                self.log_text.append("Güç Seçeneklerine CPU Frekansı Ayarı Getirme/Kaldırma tweak'i uygulandı")

        # Tweaklerin uygulanması tamamlandığında kullanıcıya bilgi veriliyor
        QMessageBox.information(self, "Tweakler Uygulandı", "Seçilen tweakler uygulandı!")               

        
        self.update_available = False  # Güncelleme kontrolü için bir bayrak
    
    def add_updates_tab(self, tab):
        layout = QVBoxLayout()

        check_updates_button = QPushButton("Güncelleştirmeleri Denetle")
        check_updates_button.clicked.connect(self.check_updates)
        layout.addWidget(check_updates_button)

        self.update_label = QLabel("")  # Güncelleme çıktısını göstereceğimiz etiket
        layout.addWidget(self.update_label)

        self.apply_updates_button = QPushButton("Güncelleştirmeleri Uygula")
        self.apply_updates_button.clicked.connect(self.apply_updates)
        self.apply_updates_button.setEnabled(False)  # Başlangıçta devre dışı bırakıldı
        layout.addWidget(self.apply_updates_button)

        tab.setLayout(layout)
        
    def check_updates(self):
        result = subprocess.run(["winget", "upgrade"], capture_output=True, text=True)
        output = result.stdout
        
        self.update_output = output
        
        self.update_label.setText(output)
        # Eğer güncelleme varsa, güncelleme butonunu etkinleştir
        if "No updates found" not in output:
            self.update_available = True
            self.apply_updates_button.setEnabled(True)
            

    def apply_updates(self):
        if self.update_available:
            subprocess.run(["winget", "upgrade", "--all"])
            self.update_label.setText("Güncellemeler uygulandı!")
            self.update_available = False  # Güncelleme uygulandıktan sonra bayrağı sıfırla
            self.apply_updates_button.setEnabled(False)  # Butonu tekrar devre dışı bırak
            
            # Kullanıcıya güncellemelerin tamamlandığını bildiren bir ileti kutusu göster
            QMessageBox.information(self, "Güncelleme Tamamlandı", "Güncelleştirmeler başarıyla tamamlandı!")



    def get_installed_programs(self):
        installed_programs = []
        uninstall_key = r"Software\Microsoft\Windows\CurrentVersion\Uninstall"

        # HKEY_LOCAL_MACHINE altındaki programlar
        with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, uninstall_key) as key:
            for i in range(winreg.QueryInfoKey(key)[0]):
                sub_key_name = winreg.EnumKey(key, i)
                with winreg.OpenKey(key, sub_key_name) as sub_key:
                    try:
                        program_name = winreg.QueryValueEx(sub_key, "DisplayName")[0]
                        installed_programs.append(program_name)
                    except FileNotFoundError:
                        continue

        # HKEY_CURRENT_USER altındaki programlar
        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, uninstall_key) as key:
            for i in range(winreg.QueryInfoKey(key)[0]):
                sub_key_name = winreg.EnumKey(key, i)
                with winreg.OpenKey(key, sub_key_name) as sub_key:
                    try:
                        program_name = winreg.QueryValueEx(sub_key, "DisplayName")[0]
                        installed_programs.append(program_name)
                    except FileNotFoundError:
                        continue

        return installed_programs

    def listeyi_guncelle(self):
        self.program_list.clear()
        
        installed_programs = self.get_installed_programs()
        self.program_list.addItems(installed_programs)

    def add_uninstall_tab(self, tab):
        layout = QVBoxLayout()

        self.program_list = QListWidget()  # Yüklü programları listelemek için QListWidget kullanıyoruz
        self.populate_program_list()  # Yüklü programları listelemek için fonksiyonu çağırıyoruz
        layout.addWidget(self.program_list)

        remove_button = QPushButton("Seçilen Programı Kaldır")
        remove_button.clicked.connect(self.remove_selected_program)
        layout.addWidget(remove_button)

        update_list_button = QPushButton("Listeyi Güncelle")
        update_list_button.clicked.connect(self.listeyi_guncelle)
        layout.addWidget(update_list_button)

        tab.setLayout(layout)
        
    def populate_program_list(self):
        installed_programs = self.get_installed_programs()
        self.program_list.addItems(installed_programs)


    def remove_selected_program(self):
        selected_program = self.program_list.currentItem().text()
        confirm = QMessageBox.question(
            self, "Programı Kaldır", f"{selected_program} programını kaldırmak istiyor musunuz?", QMessageBox.Yes | QMessageBox.No)

        if confirm == QMessageBox.Yes:
            try:
                result = subprocess.run(["winget", "uninstall", selected_program, "--force"], capture_output=True, text=True)
                if result.returncode == 0:
                    QMessageBox.information(
                        self, "Başarılı", f"{selected_program} başarıyla kaldırıldı.")
                    self.listeyi_guncelle()  # Kaldırıldıktan sonra program listesini yenile
                else:
                    QMessageBox.critical(
                        self, "Hata", f"{selected_program} kaldırılamadı.")
            except Exception as e:
                QMessageBox.critical(
                    self, "Hata", f"Program kaldırma sırasında bir hata oluştu: {str(e)}")
        else:
            QMessageBox.information(
                self, "İşlem İptal Edildi", "Program kaldırma işlemi iptal edildi.")
    def add_about_tab(self, tab):
        layout = QVBoxLayout()
        about_label = self._extracted_from_add_about_tab_3(
            "Program Yöneticisi, kullanıcıların kolayca programları yönetmelerine olanak tanıyan bir araçtır."
            "Bu arayüz, program kurulumunu, tweak uygulamayı, güncellemeleri yapmayı ve programları kaldırmayı kolaylaştırır.",
            layout,
        )
        about_label.setWordWrap(True)

        contact_label = self._extracted_from_add_about_tab_3(
            "İletişim ve Öneriler\n\n"
            "Herhangi bir geri bildiriminiz, öneriniz veya sorunuz varsa lütfen bize ulaşın.\n"
            "E-posta: kemal.saydut@gmail.com\n\n"
            "Programı geliştirmemize yardımcı olacak tüm geri bildirimleri bekliyoruz. Teşekkür ederiz!",
            layout,
        )
        tab.setLayout(layout)

    # TODO Rename this here and in `add_about_tab`
    def _extracted_from_add_about_tab_3(self, arg0, layout):
        about_text = arg0

        result = QLabel(about_text)
        layout.addWidget(result)
        return result
        
    def run_subprocess(self, command, log_output=True):
        result = subprocess.run(command, capture_output=True, text=True)
        if log_output:
            output = result.stdout
            self.log_text.append(output)
            self.log_text.repaint()
        return result

    def install_programs(self, checkboxes):
        selected_programs = [checkbox.text() for checkbox in checkboxes if checkbox.isChecked()]
        self.log_text.clear()

        program_actions = {
            "Visual Studio programlari -Hepsi bir arada- (Oyunlar icin)": lambda: [
                self.run_subprocess([os.path.join(redistler_dir, exe)], shell=True) for exe in [
                    "2005_x64.exe", "2005_x86.exe", "2008_x64.exe", "2008_x86.exe", "2010_x64.exe", "2010_x86.exe",
                    "2012_x64.exe", "2012_x86.exe", "2013_x64.exe", "2013_x86.exe", "2015_2017_2019_2022_x64.exe",
                    "2015_2017_2019_2022_x86.exe"
                ]
            ],
            # Diğer program işlemlerini buraya ekleyin
        }

        for program in selected_programs:
            action = program_actions.get(program, lambda: self.run_subprocess(["winget", "install", program, "--source", "winget"]))
            action()

        QMessageBox.information(self, "Kurulum Tamamlandı", "Seçilen programların kurulumu tamamlandı!")



    def add_system_info_tab(self, tab):
        layout = QVBoxLayout()

        system_info_label = QLabel("Sistem Bilgileri:")
        layout.addWidget(system_info_label)

        # Sistem bilgilerini göstermek için bir QTextEdit bileşeni
        self.system_info_text = QTextEdit()
        self.system_info_text.setReadOnly(True)  # Kullanıcı tarafından düzenlenemez yapılıyor
        layout.addWidget(self.system_info_text)

        refresh_button = QPushButton("Bilgileri Yenile")
        refresh_button.clicked.connect(self.refresh_system_info)
        layout.addWidget(refresh_button)

        tab.setLayout(layout)
        self.refresh_system_info()



    def add_gpu_info_to_system_tab(self, tab):
            layout = tab.layout() #var olan layoutu alıyoruz
            try:
                gpu_info_text = QTextEdit()
                gpu_info_text.setReadOnly(True)
                gpu_info_text.setPlainText(self.get_gpu_info())#gpu bilgisi ekleme
                layout.addWidget(gpu_info_text)

            except Exception as e:
                print(f"Hata: {str(e)}")
        
    def get_gpu_info(self):
        try:
            platforms = cl.get_platforms()
            devices = [platform.get_devices(device_type=cl.device_type.GPU) for platform in platforms]

            gpu_info = []
            for idx, platform in enumerate(platforms):
                gpu_info.append(f"Platform {idx + 1}: {platform.name}")
                for device in devices[idx]:
                    gpu_info.extend(
                        (
                            f"Device Name: {device.name}",
                            f"Device Version: {device.version}",
                            f"Device Type: {cl.device_type.to_string(device.type)}",
                            f"Device Global Memory: {device.global_mem_size // 1024**3} GB",
                            f"Device Local Memory: {device.local_mem_size // 1024} KB",
                            f"Device Max Clock Frequency: {device.max_clock_frequency} MHz",
                            "-" * 30,
                        )
                    )
            return "\n".join(gpu_info)
        except ImportError:
            return "PyOpenCL kütüphanesi bulunamadı. Lütfen yükleyin."
        except Exception as e:
            return f"Hata: {str(e)}"
        
        
    def refresh_system_info(self):
        cpu_info = f"Işlemci: {cpuinfo.get_cpu_info()['brand_raw']}\n"
        cpu_info += f"Işlemci Sayısı: {psutil.cpu_count(logical=False)}\n"
        cpu_info += f"İş Parçacığı Sayısı: {psutil.cpu_count(logical=True)}\n\n"

        mem_info = psutil.virtual_memory()
        mem_total = round(mem_info.total / (1024 ** 3), 2)
        mem_available = round(mem_info.available / (1024 ** 3), 2)
        mem_percent = mem_info.percent
        mem_info_str = f"Bellek: {mem_available} GB / {mem_total} GB kullanıldı ({mem_percent}%)\n\n"

        os_info = f"İşletim Sistemi: {platform.uname().system} {platform.uname().release}\n\n"

        disk_usage = psutil.disk_usage('/')
        disk_info = f"Toplam Depolama: {disk_usage.total / (1024 ** 3):.2f} GB\n"
        disk_info += f"Kullanılan Alan: {disk_usage.used / (1024 ** 3):.2f} GB\n"
        disk_info += f"Boş Alan: {disk_usage.free / (1024 ** 3):.2f} GB\n\n"

        network_info = psutil.net_if_addrs()
        network_str = "Ağ Bağlantıları:\n"
        for interface, addrs in network_info.items():
            network_str += f"Interface: {interface}\n"
            for addr in addrs:
                if hasattr(addr, 'family') and addr.family == getattr(psutil, 'AF_INET', None):
                    network_str += f"IP Adresi: {addr.address}\n"
                    network_str += f"Alt Ağ Maskesi: {addr.netmask}\n"
        network_str += "\n"
        
        gpu_info = self.get_gpu_info()
        system_info = cpu_info + mem_info_str + os_info + disk_info + network_str + gpu_info
        self.system_info_text.setText(system_info)
        
    def get_gpu_info(self):
        try:
            platforms = cl.get_platforms()
            devices = [platform.get_devices(device_type=cl.device_type.GPU) for platform in platforms]

            gpu_info = []
            for idx, platform in enumerate(platforms):
                gpu_info.append(f"Platform {idx + 1}: {platform.name}")
                for device in devices[idx]:
                    gpu_info.extend(
                        (
                            f"Device Name: {device.name}",
                            f"Device Version: {device.version}",
                            f"Device Type: {cl.device_type.to_string(device.type)}",
                            f"Device Global Memory: {device.global_mem_size // (1024 ** 3)} GB",
                            f"Device Local Memory: {device.local_mem_size // 1024} KB",
                            f"Device Max Clock Frequency: {device.max_clock_frequency} MHz",
                            "-" * 30,
                        )
                    )
            return "\n".join(gpu_info)
        except ImportError:
            return "PyOpenCL kütüphanesi bulunamadı. Lütfen yükleyin."
        except Exception as e:
            return f"Hata: {str(e)}"
        
    def create_menu(self):
        main_menu = self.menuBar()
        view_menu = main_menu.addMenu('Temalar')

        dark_theme_action = QAction('Karanlık Tema', self)
        dark_theme_action.setStatusTip('Karanlık Tema Uygula')
        dark_theme_action.triggered.connect(self.apply_dark_theme)
        view_menu.addAction(dark_theme_action)

        light_theme_action = QAction('Açık Tema', self)
        light_theme_action.setStatusTip('Açık Tema Uygula')
        light_theme_action.triggered.connect(self.apply_light_theme)
        view_menu.addAction(light_theme_action)

    def apply_dark_theme(self):
        self.setStyleSheet(qdarkstyle.load_stylesheet(qt_api='pyqt5'))

    def apply_light_theme(self):
        self.setStyleSheet('')

def run_app():
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

if __name__ == "__main__":
    run_app()