Merge pull request #844 from dortania/wxPython-demo

Implement wxPython Based GUI

resources/build.py

@@ -478,20 +478,8 @@ class BuildOpenCore:
                 # Used to enable Audio support for non-standard dGPUs
                 self.enable_kext("AppleALC.kext", self.constants.applealc_version, self.constants.applealc_path)
 
-        def check_firewire(model):
-            # MacBooks never supported FireWire
-            # Pre-Thunderbolt MacBook Airs as well
-            if model.startswith("MacBookPro"):
-                return True
-            elif model.startswith("MacBookAir"):
-                if smbios_data.smbios_dictionary[self.model]["CPU Generation"] < cpu_data.cpu_data.sandy_bridge.value:
-                    return False
-            elif model.startswith("MacBook"):
-                return False
-            else:
-                return True
 
-        if self.constants.firewire_boot is True and check_firewire(self.model) is True:
+        if self.constants.firewire_boot is True and generate_smbios.check_firewire(self.model) is True:
             # Enable FireWire Boot Support
             # Applicable for both native FireWire and Thunderbolt to FireWire adapters
             print("- Enabling FireWire Boot Support")

resources/cli_menu.py

@@ -880,12 +880,13 @@ Supported Options:
         change_menu = input("Set FeatreUnlock (ie. 1): ")
         if change_menu == "1":
             self.constants.fu_status = True
-            self.constants.fu_arguments = ""
+            self.constants.fu_arguments = None
         elif change_menu == "2":
             self.constants.fu_status = True
             self.constants.fu_arguments = " -disable_sidecar_mac"
         elif change_menu == "3":
             self.constants.fu_status = False
+            self.constants.fu_arguments = None
         else:
             print("Invalid input, returning to previous menu")
             self.set_fu_settings()
@@ -1189,11 +1190,14 @@ B. Exit
             self.download_macOS()
 
     def download_install_assistant(self, link):
-        installer.download_install_assistant(self.constants.payload_path, link)
-        installer.install_macOS_installer(self.constants.payload_path)
-        input("Press any key to continue...")
-        # To avoid selecting the wrong installer by mistake, let user select the correct one
-        self.find_local_installer()
+        if installer.download_install_assistant(self.constants.payload_path, link):
+            installer.install_macOS_installer(self.constants.payload_path)
+            input("Press any key to continue...")
+            # To avoid selecting the wrong installer by mistake, let user select the correct one
+            self.find_local_installer()
+        else:
+            print("Failed to start download")
+            input("Press any key to continue...")
 
     
     def download_macOS_installer(self):

resources/constants.py

@@ -124,8 +124,8 @@ class Constants:
         self.override_smbios = "Default"  # Set SMBIOS model used
 
         ## FeatureUnlock Settings
-        self.fu_status = True   # Enable FeatureUnlock
-        self.fu_arguments = ""  # Set FeatureUnlock arguments
+        self.fu_status = True   #   Enable FeatureUnlock
+        self.fu_arguments = None  # Set FeatureUnlock arguments
 
         ## Latebloom Settings
         self.latebloom_status = False  # Latebloom Enabled

resources/generate_smbios.py

@@ -1,4 +1,4 @@
-from data import smbios_data, os_data
+from data import smbios_data, os_data, cpu_data
 from resources import utilities
 
 
@@ -98,3 +98,16 @@ def find_model_off_board(board):
                 key = "MacPro5,1"
             return key
     return None
+
+def check_firewire(model):
+    # MacBooks never supported FireWire
+    # Pre-Thunderbolt MacBook Airs as well
+    if model.startswith("MacBookPro"):
+        return True
+    elif model.startswith("MacBookAir"):
+        if smbios_data.smbios_dictionary[model]["CPU Generation"] < cpu_data.cpu_data.sandy_bridge.value:
+            return False
+    elif model.startswith("MacBook"):
+        return False
+    else:
+        return True

resources/installer.py

@@ -54,7 +54,9 @@ def create_installer(installer_path, volume_name):
 
 def download_install_assistant(download_path, ia_link):
     # Downloads InstallAssistant.pkg
-    utilities.download_file(ia_link, (Path(download_path) / Path("InstallAssistant.pkg")))
+    if utilities.download_file(ia_link, (Path(download_path) / Path("InstallAssistant.pkg"))):
+        return True
+    return False
 
 def install_macOS_installer(download_path):
     args = [
@@ -85,41 +87,41 @@ def list_downloadable_macOS_installers(download_path, catalog):
         link = "https://swscan.apple.com/content/catalogs/others/index-12customerseed-12-10.16-10.15-10.14-10.13-10.12-10.11-10.10-10.9-mountainlion-lion-snowleopard-leopard.merged-1.sucatalog.gz"
     
     # Download and unzip the catalog
-    utilities.download_file(link, (Path(download_path) / Path("seed.sucatalog.gz")))
-    subprocess.run(["gunzip", "-d", "-f", Path(download_path) / Path("seed.sucatalog.gz")])
-    catalog_plist = plistlib.load((Path(download_path) / Path("seed.sucatalog")).open("rb"))
+    if utilities.download_file(link, (Path(download_path) / Path("seed.sucatalog.gz"))):
+        subprocess.run(["gunzip", "-d", "-f", Path(download_path) / Path("seed.sucatalog.gz")])
+        catalog_plist = plistlib.load((Path(download_path) / Path("seed.sucatalog")).open("rb"))
 
-    for item in catalog_plist["Products"]:
-        try:
-            # Check if entry has SharedSupport and BuildManifest
-            # Ensures only Big Sur and newer Installers are listed
-            catalog_plist["Products"][item]["ExtendedMetaInfo"]["InstallAssistantPackageIdentifiers"]["SharedSupport"]
-            catalog_plist["Products"][item]["ExtendedMetaInfo"]["InstallAssistantPackageIdentifiers"]["BuildManifest"]
+        for item in catalog_plist["Products"]:
+            try:
+                # Check if entry has SharedSupport and BuildManifest
+                # Ensures only Big Sur and newer Installers are listed
+                catalog_plist["Products"][item]["ExtendedMetaInfo"]["InstallAssistantPackageIdentifiers"]["SharedSupport"]
+                catalog_plist["Products"][item]["ExtendedMetaInfo"]["InstallAssistantPackageIdentifiers"]["BuildManifest"]
 
-            for bm_package in catalog_plist["Products"][item]["Packages"]:
-                if "BuildManifest.plist" in bm_package["URL"]:
-                    utilities.download_file(bm_package["URL"], (Path(download_path) / Path("BuildManifest.plist")))
-                    build_plist = plistlib.load((Path(download_path) / Path("BuildManifest.plist")).open("rb"))
-                    version = build_plist["ProductVersion"]
-                    build = build_plist["ProductBuildVersion"]
-                    for ia_package in catalog_plist["Products"][item]["Packages"]:
-                        if "InstallAssistant.pkg" in ia_package["URL"]:
-                            download_link = ia_package["URL"]
-                            size = ia_package["Size"]
-                            integrity = ia_package["IntegrityDataURL"]
+                for bm_package in catalog_plist["Products"][item]["Packages"]:
+                    if "BuildManifest.plist" in bm_package["URL"]:
+                        utilities.download_file(bm_package["URL"], (Path(download_path) / Path("BuildManifest.plist")))
+                        build_plist = plistlib.load((Path(download_path) / Path("BuildManifest.plist")).open("rb"))
+                        version = build_plist["ProductVersion"]
+                        build = build_plist["ProductBuildVersion"]
+                        for ia_package in catalog_plist["Products"][item]["Packages"]:
+                            if "InstallAssistant.pkg" in ia_package["URL"]:
+                                download_link = ia_package["URL"]
+                                size = ia_package["Size"]
+                                integrity = ia_package["IntegrityDataURL"]
 
-                    avalible_apps.update({
-                        item: {
-                            "Version": version,
-                            "Build": build,
-                            "Link": download_link,
-                            "Size": size,
-                            "integrity": integrity,
-                            "Source": "Apple Inc.",
-                        }
-                    })
-        except KeyError:
-            pass
+                        avalible_apps.update({
+                            item: {
+                                "Version": version,
+                                "Build": build,
+                                "Link": download_link,
+                                "Size": size,
+                                "integrity": integrity,
+                                "Source": "Apple Inc.",
+                            }
+                        })
+            except KeyError:
+                pass
     return avalible_apps
 
 def format_drive(disk_id):
@@ -245,8 +247,9 @@ def generate_installer_creation_script(script_location, installer_path, disk):
 
     with script_location.open("w") as script:
         script.write(f'''#!/bin/bash
-diskutil eraseDisk HFS+ OCLP-Installer {disk}
-"{createinstallmedia_path}" --volume /Volumes/OCLP-Installer --nointeraction
+earse_disk='diskutil eraseDisk HFS+ OCLP-Installer {disk}'
+if $earse_disk; then
+    "{createinstallmedia_path}" --volume /Volumes/OCLP-Installer --nointeraction
+fi
         ''')
-    
     return True

resources/main.py

@@ -33,6 +33,8 @@ class OpenCoreLegacyPatcher:
         if "python" in launcher_binary:
             # We're running from source
             launcher_script =  __file__
+            if "main.py" in launcher_script:
+                launcher_script = launcher_script.replace("/resources/main.py", "/OpenCore-Patcher-GUI.command")
         self.constants.launcher_binary = launcher_binary
         self.constants.launcher_script = launcher_script
         defaults.generate_defaults.probe(self.computer.real_model, True, self.constants)

resources/run.py

@@ -0,0 +1,155 @@
+# Module for running processes with real time output
+# Written by CorpNewt
+# Source: https://github.com/corpnewt/pymodules/blob/884c3de15b6a2570afde52fe8a14a3e946ffb18a/run.py
+
+import sys, subprocess, time, threading, shlex
+try:
+    from Queue import Queue, Empty
+except:
+    from queue import Queue, Empty
+
+ON_POSIX = 'posix' in sys.builtin_module_names
+
+class Run:
+
+    def __init__(self):
+        return
+
+    def _read_output(self, pipe, q):
+        try:
+            for line in iter(lambda: pipe.read(1), b''):
+                q.put(line)
+        except ValueError:
+            pass
+        pipe.close()
+
+    def _create_thread(self, output):
+        # Creates a new queue and thread object to watch based on the output pipe sent
+        q = Queue()
+        t = threading.Thread(target=self._read_output, args=(output, q))
+        t.daemon = True
+        return (q,t)
+
+    def _stream_output(self, comm, shell = False):
+        output = error = ""
+        p = None
+        try:
+            if shell and type(comm) is list:
+                comm = " ".join(shlex.quote(x) for x in comm)
+            if not shell and type(comm) is str:
+                comm = shlex.split(comm)
+            p = subprocess.Popen(comm, shell=shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=0, universal_newlines=True, close_fds=ON_POSIX)
+            # Setup the stdout thread/queue
+            q,t   = self._create_thread(p.stdout)
+            qe,te = self._create_thread(p.stderr)
+            # Start both threads
+            t.start()
+            te.start()
+
+            while True:
+                c = z = ""
+                try: c = q.get_nowait()
+                except Empty: pass
+                else:
+                    sys.stdout.write(c)
+                    output += c
+                    sys.stdout.flush()
+                try: z = qe.get_nowait()
+                except Empty: pass
+                else:
+                    sys.stderr.write(z)
+                    error += z
+                    sys.stderr.flush()
+                if not c==z=="": continue # Keep going until empty
+                # No output - see if still running
+                p.poll()
+                if p.returncode != None:
+                    # Subprocess ended
+                    break
+                # No output, but subprocess still running - stall for 20ms
+                time.sleep(0.02)
+
+            o, e = p.communicate()
+            return (output+o, error+e, p.returncode)
+        except:
+            if p:
+                try: o, e = p.communicate()
+                except: o = e = ""
+                return (output+o, error+e, p.returncode)
+            return ("", "Command not found!", 1)
+
+    def _decode(self, value, encoding="utf-8", errors="ignore"):
+        # Helper method to only decode if bytes type
+        if sys.version_info >= (3,0) and isinstance(value, bytes):
+            return value.decode(encoding,errors)
+        return value
+
+    def _run_command(self, comm, shell = False):
+        c = None
+        try:
+            if shell and type(comm) is list:
+                comm = " ".join(shlex.quote(x) for x in comm)
+            if not shell and type(comm) is str:
+                comm = shlex.split(comm)
+            p = subprocess.Popen(comm, shell=shell, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            c = p.communicate()
+        except:
+            if c == None:
+                return ("", "Command not found!", 1)
+        return (self._decode(c[0]), self._decode(c[1]), p.returncode)
+
+    def run(self, command_list, leave_on_fail = False):
+        # Command list should be an array of dicts
+        if type(command_list) is dict:
+            # We only have one command
+            command_list = [command_list]
+        output_list = []
+        for comm in command_list:
+            args   = comm.get("args",   [])
+            shell  = comm.get("shell",  False)
+            stream = comm.get("stream", False)
+            sudo   = comm.get("sudo",   False)
+            stdout = comm.get("stdout", False)
+            stderr = comm.get("stderr", False)
+            mess   = comm.get("message", None)
+            show   = comm.get("show",   False)
+            
+            if not mess == None:
+                print(mess)
+
+            if not len(args):
+                # nothing to process
+                continue
+            if sudo:
+                # Check if we have sudo
+                out = self._run_command(["which", "sudo"])
+                if "sudo" in out[0]:
+                    # Can sudo
+                    if type(args) is list:
+                        args.insert(0, out[0].replace("\n", "")) # add to start of list
+                    elif type(args) is str:
+                        args = out[0].replace("\n", "") + " " + args # add to start of string
+            
+            if show:
+                print(" ".join(args))
+
+            if stream:
+                # Stream it!
+                out = self._stream_output(args, shell)
+            else:
+                # Just run and gather output
+                out = self._run_command(args, shell)
+                if stdout and len(out[0]):
+                    print(out[0])
+                if stderr and len(out[1]):
+                    print(out[1])
+            # Append output
+            output_list.append(out)
+            # Check for errors
+            if leave_on_fail and out[2] != 0:
+                # Got an error - leave
+                break
+        if len(output_list) == 1:
+            # We only ran one command - just return that output
+            return output_list[0]
+        return output_list

resources/sys_patch.py

@@ -85,7 +85,9 @@ class PatchSysVolume:
             else:
                 if self.constants.detected_os > os_data.os_data.catalina:
                     print("- Mounting APFS Snapshot as writable")
-                    utilities.elevated(["mount", "-o", "nobrowse", "-t", "apfs", f"/dev/{self.root_mount_path}", self.mount_location], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                    result = utilities.elevated(["mount", "-o", "nobrowse", "-t", "apfs", f"/dev/{self.root_mount_path}", self.mount_location], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+                    if result.returncode == 0:
+                        print(f"- Mounted APFS Snapshot as writable at: {self.mount_location}")
                 if Path(self.mount_extensions).exists():
                     print("- Successfully mounted the Root Volume")
                     if patch is True:
@@ -272,7 +274,7 @@ class PatchSysVolume:
                     print(bless.stdout.decode())
                     if "Can't use last-sealed-snapshot or create-snapshot on non system volume" in bless.stdout.decode():
                         print("- This is an APFS bug with Monterey! Perform a clean installation to ensure your APFS volume is built correctly")
-                    sys.exit(1)
+                    return
                 else:
                     self.unmount_drive()
             else:
@@ -954,7 +956,7 @@ set million colour before rebooting"""
     # Entry Function
     def start_patch(self):
         print("- Starting Patch Process")
-        print(f"- Determinging Required Patch set for Darwin {self.constants.detected_os}")
+        print(f"- Determining Required Patch set for Darwin {self.constants.detected_os}")
         self.detect_patch_set()
         if self.no_patch is True:
             change_menu = None

resources/sys_patch_detect.py

@@ -0,0 +1,166 @@
+from resources import constants, device_probe, utilities
+from data import model_array, os_data, smbios_data, cpu_data
+
+class detect_root_patch:
+    def __init__(self, model, versions):
+        self.model = model
+        self.constants: constants.Constants() = versions
+        self.computer = self.constants.computer
+
+        # GPU Patch Detection
+        self.nvidia_legacy= False
+        self.kepler_gpu= False
+        self.amd_ts1= False
+        self.amd_ts2= False
+        self.iron_gpu= False
+        self.sandy_gpu= False
+        self.ivy_gpu= False
+
+        # Misc Patch Detection
+        self.brightness_legacy= False
+        self.legacy_audio= False
+        self.legacy_wifi= False
+        self.legacy_gmux= False
+        self.legacy_keyboard_backlight= False
+
+        # Patch Requirements
+        self.amfi_must_disable= False
+        self.check_board_id= False
+        self.supports_metal= False
+
+    
+    def detect_gpus(self):
+        gpus = self.constants.computer.gpus
+        if self.constants.moj_cat_accel is True:
+            non_metal_os = os_data.os_data.high_sierra
+        else:
+            non_metal_os = os_data.os_data.catalina
+        for i, gpu in enumerate(gpus):
+            if gpu.class_code and gpu.class_code != 0xFFFFFFFF:
+                print(f"- Found GPU ({i}): {utilities.friendly_hex(gpu.vendor_id)}:{utilities.friendly_hex(gpu.device_id)}")
+                if gpu.arch in [device_probe.NVIDIA.Archs.Tesla, device_probe.NVIDIA.Archs.Fermi]:
+                    if self.constants.detected_os > non_metal_os:
+                        self.nvidia_legacy = True
+                        self.amfi_must_disable = True
+                        # self.legacy_keyboard_backlight = self.check_legacy_keyboard_backlight()
+                elif gpu.arch == device_probe.NVIDIA.Archs.Kepler:
+                    if self.constants.detected_os > os_data.os_data.big_sur:
+                        # Kepler drivers were dropped with Beta 7
+                        # 12.0 Beta 5: 21.0.0 - 21A5304g
+                        # 12.0 Beta 6: 21.1.0 - 21A5506j
+                        # 12.0 Beta 7: 21.1.0 - 21A5522h
+                        if self.constants.detected_os == os_data.os_data.monterey and self.constants.detected_os_minor > 0:
+                            if "21A5506j" not in self.constants.detected_os_build:
+                                self.kepler_gpu = True
+                                self.supports_metal = True
+                elif gpu.arch == device_probe.AMD.Archs.TeraScale_1:
+                    if self.constants.detected_os > non_metal_os:
+                        self.amd_ts1 = True
+                        self.amfi_must_disable = True
+                elif gpu.arch == device_probe.AMD.Archs.TeraScale_2:
+                    if self.constants.detected_os > non_metal_os:
+                        self.amd_ts2 = True
+                        self.amfi_must_disable = True
+                elif gpu.arch == device_probe.Intel.Archs.Iron_Lake:
+                    if self.constants.detected_os > non_metal_os:
+                        self.iron_gpu = True
+                        self.amfi_must_disable = True
+                elif gpu.arch == device_probe.Intel.Archs.Sandy_Bridge:
+                    if self.constants.detected_os > non_metal_os:
+                        self.sandy_gpu = True
+                        self.amfi_must_disable = True
+                        self.check_board_id = True
+                elif gpu.arch == device_probe.Intel.Archs.Ivy_Bridge:
+                    if self.constants.detected_os > os_data.os_data.big_sur:
+                        self.ivy_gpu = True
+                        self.supports_metal = True
+        if self.supports_metal is True:
+            # Avoid patching Metal and non-Metal GPUs if both present, prioritize Metal GPU
+            # Main concerns are for iMac12,x with Sandy iGPU and Kepler dGPU
+            self.nvidia_legacy = False
+            self.amd_ts1 = False
+            self.amd_ts2 = False
+            self.iron_gpu = False
+            self.sandy_gpu = False
+    
+    def check_dgpu_status(self):
+        dgpu = self.constants.computer.dgpu
+        if dgpu:
+            if dgpu.class_code and dgpu.class_code == 0xFFFFFFFF:
+                # If dGPU is disabled via class-codes, assume demuxed
+                return False
+            return True
+        return False
+
+    def detect_demux(self):
+        # If GFX0 is missing, assume machine was demuxed
+        # -wegnoegpu would also trigger this, so ensure arg is not present
+        if not "-wegnoegpu" in (utilities.get_nvram("boot-args") or ""):
+            igpu = self.constants.computer.igpu
+            dgpu = self.check_dgpu_status()
+            if igpu and not dgpu:
+                return True
+        return False
+    
+    def check_legacy_keyboard_backlight(self):
+        # With Big Sur and newer, Skylight patch set unfortunately breaks native keyboard backlight
+        # Penryn Macs are able to re-enable the keyboard backlight by simply running '/usr/libexec/TouchBarServer'
+        # For Arrendale and newer, this has no effect.
+        if self.model.startswith("MacBookPro") or self.model.startswith("MacBookAir"):
+            # non-Metal MacBooks never had keyboard backlight
+            if smbios_data.smbios_dictionary[self.model]["CPU Generation"] <= cpu_data.cpu_data.penryn.value:
+                if self.constants.detected_os > os_data.os_data.catalina:
+                    return True
+        return False
+
+    def detect_patch_set(self):
+        self.detect_gpus()
+        if self.model in model_array.LegacyBrightness:
+            if self.constants.detected_os > os_data.os_data.catalina:
+                self.brightness_legacy = True
+
+        if self.model in ["iMac7,1", "iMac8,1"] or (self.model in model_array.LegacyAudio and utilities.check_kext_loaded("AppleALC", self.constants.detected_os) is False):
+            # Special hack for systems with botched GOPs
+            # TL;DR: No Boot Screen breaks Lilu, therefore breaking audio
+            if self.constants.detected_os > os_data.os_data.catalina:
+                self.legacy_audio = True
+
+        if (
+            isinstance(self.constants.computer.wifi, device_probe.Broadcom)
+            and self.constants.computer.wifi.chipset in [device_probe.Broadcom.Chipsets.AirPortBrcm4331, device_probe.Broadcom.Chipsets.AirPortBrcm43224]
+        ) or (isinstance(self.constants.computer.wifi, device_probe.Atheros) and self.constants.computer.wifi.chipset == device_probe.Atheros.Chipsets.AirPortAtheros40):
+            if self.constants.detected_os > os_data.os_data.big_sur:
+                self.legacy_wifi = True
+
+        # if self.model in ["MacBookPro5,1", "MacBookPro5,2", "MacBookPro5,3", "MacBookPro8,2", "MacBookPro8,3"]:
+        if self.model in ["MacBookPro8,2", "MacBookPro8,3"]:
+            # Sierra uses a legacy GMUX control method needed for dGPU switching on MacBookPro5,x
+            # Same method is also used for demuxed machines
+            # Note that MacBookPro5,x machines are extremely unstable with this patch set, so disabled until investigated further
+            # Ref: https://github.com/dortania/OpenCore-Legacy-Patcher/files/7360909/KP-b10-030.txt
+            if self.constants.detected_os > os_data.os_data.high_sierra:
+                if self.model in ["MacBookPro8,2", "MacBookPro8,3"]:
+                    # Ref: https://doslabelectronics.com/Demux.html
+                    if self.detect_demux() is True:
+                        self.legacy_gmux = True
+                else:
+                    self.legacy_gmux = True
+        
+        self.root_patch_dict = {
+            "Graphics: Nvidia Tesla": self.nvidia_legacy,
+            "Graphics: Nvidia Kepler": self.kepler_gpu,
+            "Graphics: AMD TeraScale 1": self.amd_ts1,
+            "Graphics: AMD TeraScale 2": self.amd_ts2,
+            "Graphics: Intel Ironlake": self.iron_gpu,
+            "Graphics: Intel Sandy Bridge": self.sandy_gpu,
+            "Graphics: Intel Ivy Bridge": self.ivy_gpu,
+            "Brightness: Legacy Backlight Control": self.brightness_legacy,
+            "Audio: Legacy Realtek": self.legacy_audio,
+            "Networking: Legacy Wireless": self.legacy_wifi,
+            "Miscellaneous: Legacy GMUX": self.legacy_gmux,
+            "Miscellaneous: Legacy Keyboard Backlight": self.legacy_keyboard_backlight,
+            "Settings: Requires AMFI exemption": self.amfi_must_disable,
+            "Settings: Requires Board ID validation": self.check_board_id,
+        }
+        
+        return self.root_patch_dict

resources/utilities.py

@@ -373,7 +373,7 @@ def download_file(link, location, is_gui=None):
             print(f"https://github.com/dortania/OpenCore-Legacy-Patcher/releases/download/{constants.Constants().patcher_version}/OpenCore-Patcher-TUI-Offline.app.zip")
         else:
             print(link)
-        sys.exit()
+        return None
 
 def elevated(*args, **kwargs) -> subprocess.CompletedProcess:
     # When runnign through our GUI, we run as root, however we do not get uid 0