Update CLI

Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/319

.flake8

@@ -1,4 +1,4 @@
 [flake8]
-ignore = E501
+extend-ignore = E501, E203
 per-file-ignores =
     Resources/Constants.py:E704

.github/workflows/build-app.yml

@@ -13,10 +13,8 @@ jobs:
     steps:
       - uses: actions/checkout@v2
 
-      # - name: Install Python Dependencies
+      - name: Install Python Dependencies
-      #   run: |
+        run: pip3 install --upgrade pyinstaller requests
-      #     python3 -m pip install -U pip
-      #     pip3 install pyinstaller
 
       - run: pyinstaller OpenCore-Patcher.spec
       - run: ./after_pyinstaller.sh

.github/workflows/build-cli.yml

@@ -12,6 +12,9 @@ jobs:
     runs-on: self-hosted
     steps:
       - uses: actions/checkout@v2
+      - name: Install Python Dependencies
+        run: pip3 install --upgrade pyinstaller requests
+
       - run: pyinstaller OCLP-CLI.spec
       - run: cd dist; zip ../OCLP-CLI.zip OCLP-CLI
       - name: Upload Binary to Artifacts

.gitignore

@@ -1,6 +1,7 @@
 .DS_Store
 OCLP-GUI.command
 /payloads/Apple
+/payloads/Apple.zip
 /payloads/__MACOSX
 /App
 /Build-Folder

CHANGELOG.md

@@ -1,6 +1,43 @@
 # OpenCore Legacy Patcher changelog
 
+## 0.2.2
+
+- Fix IORegistry issue
+- Fix Root Patch Failure on Nvidia Tesla GPUs
+
+## 0.2.1
+
+- Fix NVMe Crash on build
+
+## 0.2.0
+
+- Refactor device probe logic
+- Implement PatcherSupportPkg v0.0.10
+  - Reduces binary sizes depending on OS
+  - Deprecates Apple-Binaries-OCLP
+- Fix full screen and Airplay to Mac support for Intel HD4000 iGPUs in Monterey
+- Automatically set `CMIO_Unit_Input_ASC.DoNotUseOpenCL` on TeraScale 2 GPUs
+- Fix Country Code detection on Wireless Cards
+- Add Windows detection and prompt during installation
+- Fix Google Fonts rendering for Intel HD4000 iGPUs in Monterey
+- Increment Binaries
+  - Lilu 1.5.4 rolling (f69a972 - 06-20-2021)
+  - RestrictEvents 1.0.3 rolling (3773ce2 - 06-20-2021)
+  - SidecarFixup 1.0.2 rolling (2c29166 - 06-21-2021)
+- Allow AirPlay to Mac support on Skylake - Coffeelake Macs
+
+## 0.1.9
+
+- Fix incorrect AMFI and SIP detection
+
+## 0.1.8
+
+- Fix Kernel Panic in Big Sur and Monterey
+- Increment binaries:
+  - Lilu (1.5.4 rolling - 06-15-2021)
+
 ## 0.1.7
+
 - Add FireWire Boot Support for Catalina and newer
 - Add NVMe firmware support for older models (ie. MacPro3,1)
   - OpenCore must be stored on a bootable volume (ie. USB or SATA)
@@ -41,6 +78,7 @@
   - User configurable, those prone to seizures are recommended to avoid or have another setup the machine due to initial colour strobing before forcing Million Colours on the display with SwitchResX or ResXtreme
 
 ## 0.1.6
+
 - Add XHCI UEFI Driver for 3rd Party USB 3.0 Controllers
   - Allows for Boot Support from OpenCore' Picker
 - Fix UEFI output on MacPro3,1 with PC GPUs
@@ -57,6 +95,7 @@
 - Fix GPU Switching on MacBookPro6,x
 
 ## 0.1.5
+
 - Fix crashing when Wireless module not present
 - Add iMac10,1 default dGPU pathing
 - Add agdpmod=vit9696 to all Nvidia Metal iMacs
@@ -72,9 +111,11 @@
 - Add SeedUtil option to Advanced Patcher Settings
 
 ## 0.1.4
+
 - Fix Device Path formatting on 2012+ iMacs
 
 ## 0.1.3
+
 - Fix internal PCIe devices reporting as external
   - Opt for `built-in` when device path is detectable
   - Innie 0ccd95e (1.3.0 release - 01-16-2021)
@@ -93,6 +134,7 @@
 - Fix NVMe properties not applying when OpenCore is installed
 
 ## 0.1.2
+
 - Fix IDE support on 2008 era MacBooks, iMacs and Xserves
 - Fix reduced output speeds on BCM94360 series Wifi cards
 - Fix accidentally disabling non-existent iGPU in iMac11,2
@@ -118,6 +160,7 @@
   - SidecarFixup efdf11c (1.0.0 release - 05-02-2021)
 
 ## 0.1.1
+
 - Fix iMac11,3 GFX0 pathing
 - Add MouSSE support to iMac10,1 with Metal AMD GPU
 - Fix iMac11,1 and iMac11,3 Nvidia boot issues after PRAM reset
@@ -137,9 +180,11 @@
 - Fix Acceleration Linking for Intel Ironlake iGPUs
 
 ## 0.1.0
+
 - Fix crash on iMacs with Metal GPUs
 
 ## 0.0.23
+
 - Fix MacBookPro4,1 15" and 17" audio support
 - Fix iMac7,1 24" and iMac9,1 24" audio support
 - Fix Macmini4,1 audio support
@@ -160,6 +205,7 @@
 - Disable SIP and SecureBootModel by default on legacy GPUs
 
 ## 0.0.22
+
 - Add ExFat support for models missing driver
   - Aids BootCamp support for EFI based installs on 2010 and older Macs
 - Fix CPU Boosting on 2011 and older Macs
@@ -168,11 +214,13 @@
 - Add BCM94322 and BCM94321 chipset support
 
 ## 0.0.21
+
 - Fix botched images in OpenCanopy
 - Add support for 3rd party OpenCore usage detection during building
   - Mainly for users transitioning from Ausdauersportler's OpenCore configuration
 
 ## 0.0.20
+
 - Fix CPU Calculation on early MCP79 chipsets (ie. iMac9,1, MacBook5,x)
 - Increment binaries
   - OpenCore c528597 (0.6.8 release - 2021-04-05)
@@ -188,6 +236,7 @@
 - Fix Mac Pro and Xserve output issues
 
 ## 0.0.19
+
 - Add SMC-Spoof.kext to avoid triggering `smcupdater`
 - Add Root Volume patching for older machines
   - AppleHDA Patch for 2011 and older (Excluding MacPro4,1+)
@@ -206,6 +255,7 @@
 - Fix Broadcom Ethernet on older 2009-2011 Macs
 
 ## 0.0.18
+
 - Disable Vault by default due to breaking installations
 - Move BOOTx64.efi to System/Library/CoreServices/ to support GPT BootCamp installs
 - Disable verbose by default, still configurable by end-user
@@ -216,9 +266,11 @@
 - Add custom drive icons for external drives
 
 ## 0.0.17
+
 - Fix build detection breaking on older OS
 
 ## 0.0.16
+
 - Move Serial selection to Patcher Settings
 - Add new SMBIOS patching options:
   - Minimal: Only update board ID and BIOSVersion, keep original serials
@@ -237,12 +289,14 @@
 - Enable `amfi_get_out_of_my_way=1` when SIP is disabled
 
 ## 0.0.15
+
 - Add user-configurable OpenCore DEBUG builds
 - Add user-configurable Wifi and GPU patches
 - Fix ThirdPartyDrives model detection
 - Add HW_BID injection to fix boot.efi error
 
 ## 0.0.14
+
 - Enable ThirdPartyDrives to aid with hibernation on 3rd party SATA drives
 - Increment OpenCore 7bb41aa (0.6.8 rolling, 2021-03-06)
 - Add ForceBooterSignature to resolve hibernation issues
@@ -251,6 +305,7 @@
 - Add GopPassThrough quirk for UGA-based systems
 
 ## 0.0.13
+
 - Add CPUFriend support to resolve X86PlatformPlugin clashes
   - (1.2.3 c388a62 release)
 - Fix crash with MacBookAir5,x
@@ -258,11 +313,13 @@
 - Remove Wireless patches for BCM4328/4321(14e4:4328) due to boot issues
 
 ## 0.0.12
+
 - Convert OpenCore-Patcher binary to OpenCore-Patcher.app
 - Add Backlight patches for modded Nvidia GPUs in iMac10,x-12,x
 - Fix sleep for iMac12,x with upgraded GPUs
 
 ## 0.0.11
+
 - Re-add OpenCore GUI
 - Rewrite in py3
 - Add OpenCore-Patcher binary for releases avoiding local python requirement
@@ -274,6 +331,7 @@
 - Add Wifi card upgrade detection
 
 ## 0.0.10
+
 - Increment binaries
   - OpenCore 43f5339 (0.6.6 release)
   - Lilu d107554 (1.5.1 release)
@@ -283,38 +341,47 @@
 - Update MacBookPro SMBIOS
 
 ## 0.0.9
+
 - Resolve firmware install issues bricking Macs
 
 ## 0.0.8
+
 - Fix USB Map
 - Add HiDPI patch
 
 ## 0.0.7
+
 - Add MacPro3,1 to HID patch
 - Fix missing SSDT-CPBG patch
 - Fix BlacklistAppleUpdate
 - Add RestrictEvents kext
 
 ## 0.0.6
+
 - Fix macserial crashing
 
 ## 0.0.5
+
 - Enable hibernation support
 - Work around USB Map failing
 - Add checks whether booting with OpenCore
 - Fix MouSSE injection
 
 ## 0.0.4
+
 - Add basic audio support for legacy chipsets
 - Add patch for dual GPU machines
 
 ## 0.0.3
+
 - Fix Wireless patch logic
 
 ## 0.0.2
+
 - Expand IOHIDFamily Patch to all Nvidia chipsets
 - Fix Airdrop 1.0 support
 - Add El Capitan era wireless cards
 
 ## 0.0.1
+
 - Initial developer preview

OCLP-CLI.command

@@ -9,79 +9,55 @@ import platform
 import argparse
 from pathlib import Path
 
-from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, DeviceProbe
+from Resources import Build, ModelArray, Constants, SysPatch, device_probe, Utilities
 
 
-class OpenCoreLegacyPatcher():
+class OpenCoreLegacyPatcher:
     def __init__(self):
+        print("Loading...")
+        Utilities.disable_cls()
         self.constants = Constants.Constants()
-        self.current_model: str = None
+        self.constants.computer = device_probe.Computer.probe()
-        opencore_model: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:oem-product".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+        self.computer = self.constants.computer
-        if not opencore_model.startswith("nvram: Error getting variable"):
-            opencore_model = [line.strip().split(":oem-product	", 1)[1] for line in opencore_model.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
-            self.current_model = opencore_model
-        else:
-            self.current_model = subprocess.run("system_profiler SPHardwareDataType".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-            self.current_model = [line.strip().split(": ", 1)[1] for line in self.current_model.stdout.decode().split("\n") if line.strip().startswith("Model Identifier")][0]
         self.constants.detected_os = int(platform.uname().release.partition(".")[0])
-        if self.current_model in ModelArray.NoAPFSsupport:
-            self.constants.serial_settings = "Moderate"
-        if self.current_model in ModelArray.LegacyGPU:
-            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
-            if dgpu_vendor:
-                if (dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids)) or (dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids):
-                    self.constants.sip_status = True
-                    self.constants.secure_status = True
-                else:
-                    self.constants.sip_status = False
-                    self.constants.secure_status = False
 
-        # Logic for when user runs custom OpenCore build and do not expose it
+        custom_cpu_model_value = Utilities.get_nvram("revcpuname", "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102", decode=True)
-        # Note: This logic currently only applies for iMacPro1,1 users, see below threads on the culprits:
+        if custom_cpu_model_value is not None:
-        # - https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/post-17425857
+            # TODO: Fix to not use two separate variables
-        # - https://forums.macrumors.com/threads/opencore-on-the-mac-pro.2207814/
-        # PLEASE FOR THE LOVE OF GOD JUST SET ExposeSensitiveData CORRECTLY!!!
-        if self.current_model == "iMacPro1,1":
-            serial: str = subprocess.run("system_profiler SPHardwareDataType | grep Serial".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-            serial = [line.strip().split("Number (system): ", 1)[1] for line in serial.split("\n") if line.strip().startswith("Serial")][0]
-            true_model = subprocess.run([str(self.constants.macserial_path), "--info", str(serial)], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-            true_model = [i.partition(" - ")[2] for i in true_model.stdout.decode().split("\n") if "Model: " in i][0]
-            print(f"True Model: {true_model}")
-            if not true_model.startswith("Unknown"):
-                self.current_model = true_model
-
-        custom_cpu_model_value: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:revcpuname".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-
-        if not custom_cpu_model_value.startswith("nvram: Error getting variable"):
-            custom_cpu_model_value = [line.strip().split(":revcpuname	", 1)[1] for line in custom_cpu_model_value.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
-            if custom_cpu_model_value.split("%00")[0] != "":
             self.constants.custom_cpu_model = 1
             self.constants.custom_cpu_model_value = custom_cpu_model_value.split("%00")[0]
 
+        if "-v" in (Utilities.get_nvram("boot-args") or ""):
+            self.constants.verbose_debug = True
+
+        # Check if running in RecoveryOS
+        self.constants.recovery_status = Utilities.check_recovery()
 
         parser = argparse.ArgumentParser()
 
         # Generic building args
-        parser.add_argument('--build', help='Build OpenCore', action='store_true', required=False)
+        parser.add_argument("--build", help="Build OpenCore", action="store_true", required=False)
-        parser.add_argument('--verbose', help='Enable verbose boot', action='store_true', required=False)
+        parser.add_argument("--verbose", help="Enable verbose boot", action="store_true", required=False)
-        parser.add_argument('--debug_oc', help='Enable OpenCore DEBUG', action='store_true', required=False)
+        parser.add_argument("--debug_oc", help="Enable OpenCore DEBUG", action="store_true", required=False)
-        parser.add_argument('--debug_kext', help='Enable kext DEBUG', action='store_true', required=False)
+        parser.add_argument("--debug_kext", help="Enable kext DEBUG", action="store_true", required=False)
-        parser.add_argument('--skip_wifi', help='Skip wifi patches', action='store_true', required=False)
+        parser.add_argument("--hide_picker", help="Hide OpenCore picker", action="store_true", required=False)
-        parser.add_argument('--hide_picker', help='Hide OpenCore picker', action='store_true', required=False)
+        parser.add_argument("--disable_sip", help="Disable SIP", action="store_true", required=False)
-        parser.add_argument('--disable_sip', help='Disable SIP', action='store_true', required=False)
+        parser.add_argument("--disable_smb", help="Disable SecureBootModel", action="store_true", required=False)
-        parser.add_argument('--disable_smb', help='Disable SecureBootModel', action='store_true', required=False)
+        parser.add_argument("--vault", help="Enable OpenCore Vaulting", action="store_true", required=False)
-        parser.add_argument('--vault', help='Enable OpenCore Vaulting', action='store_true', required=False)
+        parser.add_argument("--support_all", help="Allow OpenCore on natively supported Models", action="store_true", required=False)
-        parser.add_argument('--support_all', help='Allow OpenCore on natively supported Models', action='store_true', required=False)
+        parser.add_argument("--firewire", help="Enable FireWire Booting", action="store_true", required=False)
-        parser.add_argument('--force_legacy', help='Allow acceleration on Mac Pros and Xserves', action='store_true', required=False)
+        parser.add_argument("--nvme", help="Enable NVMe Booting", action="store_true", required=False)
+        parser.add_argument("--disable_amfi", help="Disable AMFI", action="store_true", required=False)
+        parser.add_argument("--moderate_smbios", help="Moderate SMBIOS Patching", action="store_true", required=False)
 
         # Building args requiring value values
-        parser.add_argument('--model', action='store', help='Set custom model', required=False)
+        parser.add_argument("--model", action="store", help="Set custom model", required=False)
-        parser.add_argument('--metal_gpu', action='store', help='Set Metal GPU Vendor', required=False)
+        parser.add_argument("--smbios_spoof", action="store", help="Set SMBIOS patching mode", required=False)
-        parser.add_argument('--smbios_spoof', action='store', help='Set SMBIOS patching mode', required=False)
 
         # SysPatch args
-        parser.add_argument('--patch_sys_vol', help='Patches root volume', action='store_true', required=False)
+        parser.add_argument("--patch_sys_vol", help="Patches root volume", action="store_true", required=False)
-        parser.add_argument('--unpatch_sys_vol', help='Unpatches root volume, EXPERIMENTAL', action='store_true', required=False)
+        parser.add_argument("--unpatch_sys_vol", help="Unpatches root volume, EXPERIMENTAL", action="store_true", required=False)
+        parser.add_argument("--terascale_2", help="Enable TeraScale 2 Acceleration", action="store_true", required=False)
 
         args = parser.parse_args()
 
@@ -104,9 +80,6 @@ class OpenCoreLegacyPatcher():
         if args.debug_kext:
             print("- Set kext DEBUG configuration")
             self.constants.kext_debug = True
-        if args.skip_wifi:
-            print("- Set wifi skip configuration")
-            self.constants.wifi_build = True
         if args.hide_picker:
             print("- Set HidePicker configuration")
             self.constants.showpicker = False
@@ -119,19 +92,20 @@ class OpenCoreLegacyPatcher():
         if args.vault:
             print("- Set Vault configuration")
             self.constants.vault = True
-        if args.metal_gpu:
+        if args.firewire:
-            if args.metal_gpu == "Nvidia":
+            print("- Set FireWire Boot configuration")
-                print("- Set Metal GPU patches to Nvidia")
+            self.constants.firewire_boot = True
-                self.constants.metal_build = True
+        if args.nvme:
-                self.constants.imac_vendor = "Nvidia"
+            print("- Set NVMe Boot configuration")
-            elif args.metal_gpu == "AMD":
+            self.constants.nvme_boot = True
-                print("- Set Metal GPU patches to AMD")
+        if args.disable_amfi:
-                self.constants.metal_build = True
+            print("- Set Disable AMFI configuration")
-                self.constants.imac_vendor = "AMD"
+            self.constants.disable_amfi = True
-            else:
+        if args.moderate_smbios:
-                print(f"- Unknown GPU arg passed: {args.metal_gpu}")
+            print("- Set Moderate SMBIOS Patching configuration")
-                self.constants.metal_build = False
+            self.constants.serial_settings = "Moderate"
-                self.constants.imac_vendor = "None"
+        if args.model:
+            host_is_target
         if args.smbios_spoof:
             if args.smbios_spoof == "Minimal":
                 self.constants.serial_settings = "Minimal"
@@ -147,36 +121,81 @@ class OpenCoreLegacyPatcher():
             self.constants.allow_oc_everywhere = True
             self.constants.serial_settings = "None"
 
-        if args.force_legacy:
-            print("- Allowing legacy acceleration patches on newer models")
-            self.constants.assume_legacy = True
-
         if args.build:
             if args.model:
                 print(f"- Using custom model: {args.model}")
                 self.constants.custom_model = args.model
+                self.set_defaults(self.constants.custom_model, False)
                 self.build_opencore()
+            elif self.computer.real_model not in ModelArray.SupportedSMBIOS and self.constants.allow_oc_everywhere is False:
+                print(
+                    """Your model is not supported by this patcher for running unsupported OSes!"
+
+If you plan to create the USB for another machine, please select the "Change Model" option in the menu."""
+                )
+                sys.exit(1)
             else:
-                print(f"- Using detected model: {self.current_model}")
+                print(f"- Using detected model: {self.constants.computer.real_model}")
+                self.set_defaults(self.constants.custom_model, True)
                 self.build_opencore()
         if args.patch_sys_vol:
+            if args.terascale_2:
+                print("- Set TeraScale 2 Accel configuration")
+                self.constants.terascale_2_patch = True
             print("- Set System Volume patching")
             self.patch_vol()
         elif args.unpatch_sys_vol:
             print("- Set System Volume unpatching")
             self.unpatch_vol()
 
+    def set_defaults(self, model, host_is_target):
+        if model in ModelArray.LegacyGPU:
+            if (
+                host_is_target
+                and self.computer.dgpu
+                and self.computer.dgpu.arch
+                in [
+                    device_probe.AMD.Archs.Legacy_GCN,
+                    device_probe.AMD.Archs.Polaris,
+                    device_probe.AMD.Archs.Vega,
+                    device_probe.AMD.Archs.Navi,
+                    device_probe.NVIDIA.Archs.Kepler,
+                ]
+            ):
+                print("- Detected Metal GPU, overriding default configuration")
+                # Building on device and we have a native, supported GPU
+                self.constants.sip_status = True
+                # self.constants.secure_status = True  # Monterey
+                self.constants.disable_amfi = False
+            elif host_is_target:
+                 self.constants.sip_status = False  # Unsigned kexts
+                 self.constants.secure_status = False  # Root volume modified
+                 self.constants.disable_amfi = True  # Unsigned binaries
+        if model in ModelArray.ModernGPU:
+            if host_is_target and model in ["iMac13,1", "iMac13,3"] and self.computer.dgpu:
+                # Some models have a supported dGPU, others don't
+                print("- Detected Metal dGPU, overriding default configuration")
+                self.constants.sip_status = True
+            elif host_is_target:
+                 self.constants.sip_status = False  # Unsigned kexts
+                 self.constants.secure_status = False  # Modified root volume
+                 # self.constants.disable_amfi = False  # Signed bundles, Don't need to explicitly set currently
+        if model == "MacBook8,1" and host_is_target:
+             # MacBook8,1 has an odd bug where it cannot install Monterey with Minimal spoofing
+             self.constants.serial_settings == "Moderate"
+
     def patch_vol(self):
-        SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_patch()
+        SysPatch.PatchSysVolume(self.constants.custom_model or self.constants.computer.real_model, self.constants).start_patch()
 
     def unpatch_vol(self):
-        SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_unpatch()
+        SysPatch.PatchSysVolume(self.constants.custom_model or self.constants.computer.real_model, self.constants).start_unpatch()
 
     def build_opencore(self):
-        Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).build_opencore()
+        Build.BuildOpenCore(self.constants.custom_model or self.constants.computer.real_model, self.constants).build_opencore()
 
     def install_opencore(self):
-        Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).copy_efi()
+        Build.BuildOpenCore(self.constants.custom_model or self.constants.computer.real_model, self.constants).copy_efi()
+
 
 OpenCoreLegacyPatcher()
 

OCLP-CLI.spec

@@ -23,7 +23,7 @@ exe = EXE(pyz,
           a.binaries,
           a.zipfiles,
           a.datas,
-          [],
+          [('u', None, 'OPTION')],
           name='OCLP-CLI',
           debug=False,
           bootloader_ignore_signals=False,

OpenCore-Patcher.command

@@ -3,119 +3,132 @@
 
 from __future__ import print_function
 
-import plistlib
+import platform
 import subprocess
 import sys
-import platform
 
-from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, Utilities, CliMenu, DeviceProbe
+from Resources import Build, CliMenu, Constants, ModelArray, SysPatch, Utilities, device_probe
 
 
-class OpenCoreLegacyPatcher():
+class OpenCoreLegacyPatcher:
     def __init__(self):
+        print("Loading...")
         self.constants = Constants.Constants()
-        self.current_model: str = None
+        self.constants.computer = device_probe.Computer.probe()
-        self.current_model = DeviceProbe.smbios_probe().model_detect(False)
+        self.computer = self.constants.computer
         self.constants.detected_os = int(platform.uname().release.partition(".")[0])
-        if self.current_model in ModelArray.LegacyGPU:
+        self.set_defaults(self.computer.real_model, True)
-            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
 
-            if (dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids)) or (dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids):
+        custom_cpu_model_value = Utilities.get_nvram("revcpuname", "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102", decode=True)
-                self.constants.sip_status = True
+        if custom_cpu_model_value is not None:
-                self.constants.secure_status = False
+            # TODO: Fix to not use two separate variables
-                self.constants.disable_amfi = False
-            else:
-                self.constants.sip_status = False
-                self.constants.secure_status = False
-                self.constants.disable_amfi = True
-        if self.current_model in ModelArray.ModernGPU:
-            if self.current_model in ["iMac13,1", "iMac13,3"]:
-                dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
-                if not dgpu_vendor:
-                    self.constants.sip_status = False
-                    self.constants.secure_status = False
-            else:
-                self.constants.sip_status = False
-                self.constants.secure_status = False
-
-        # Logic for when user runs custom OpenCore build and do not expose it
-        # Note: This logic currently only applies for iMacPro1,1 users, see below threads on the culprits:
-        # - https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/post-17425857
-        # - https://forums.macrumors.com/threads/opencore-on-the-mac-pro.2207814/
-        # PLEASE FOR THE LOVE OF GOD JUST SET ExposeSensitiveData CORRECTLY!!!
-        if self.current_model == "iMacPro1,1":
-            serial: str = subprocess.run("system_profiler SPHardwareDataType | grep Serial".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-            serial = [line.strip().split("Number (system): ", 1)[1] for line in serial.split("\n") if line.strip().startswith("Serial")][0]
-            true_model = subprocess.run([str(self.constants.macserial_path), "--info", str(serial)], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-            true_model = [i.partition(" - ")[2] for i in true_model.stdout.decode().split("\n") if "Model: " in i][0]
-            print(f"True Model: {true_model}")
-            if not true_model.startswith("Unknown"):
-                self.current_model = true_model
-
-        custom_cpu_model_value: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:revcpuname".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-
-        if not custom_cpu_model_value.startswith("nvram: Error getting variable"):
-            custom_cpu_model_value = [line.strip().split(":revcpuname	", 1)[1] for line in custom_cpu_model_value.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
-            if custom_cpu_model_value.split("%00")[0] != "":
             self.constants.custom_cpu_model = 1
             self.constants.custom_cpu_model_value = custom_cpu_model_value.split("%00")[0]
 
-        # Check if running in RecoveryOS
+        if "-v" in (Utilities.get_nvram("boot-args") or ""):
-        self.check_recovery()
+            self.constants.verbose_debug = True
 
-    def check_recovery(self):
+        # Check if running in RecoveryOS
-        root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+        self.constants.recovery_status = Utilities.check_recovery()
-        if root_partition_info["VolumeName"] == "macOS Base System" and \
+
-            root_partition_info["FilesystemType"] == "apfs" and \
+    def set_defaults(self, model, host_is_target):
-            root_partition_info["BusProtocol"] == "Disk Image":
+        # Defaults
-            self.constants.recovery_status = True
+        self.constants.sip_status = True
+        self.constants.secure_status = False  # Default false for Monterey
+        self.constants.disable_amfi = False
+
+        if model in ModelArray.LegacyGPU:
+            if (
+                host_is_target
+                and self.computer.dgpu
+                and self.computer.dgpu.arch
+                in [
+                    device_probe.AMD.Archs.Legacy_GCN,
+                    device_probe.AMD.Archs.Polaris,
+                    device_probe.AMD.Archs.Vega,
+                    device_probe.AMD.Archs.Navi,
+                    device_probe.NVIDIA.Archs.Kepler,
+                ]
+            ):
+                # Building on device and we have a native, supported GPU
+                self.constants.sip_status = True
+                # self.constants.secure_status = True  # Monterey
+                self.constants.disable_amfi = False
             else:
-            self.constants.recovery_status = False
+                self.constants.sip_status = False  # Unsigned kexts
+                self.constants.secure_status = False  # Root volume modified
+                self.constants.disable_amfi = True  # Unsigned binaries
+        if model in ModelArray.ModernGPU:
+            if host_is_target and model in ["iMac13,1", "iMac13,3"] and self.computer.dgpu:
+                # Some models have a supported dGPU, others don't
+                self.constants.sip_status = True
+                # self.constants.secure_status = True  # Monterey
+                # self.constants.disable_amfi = False  # Signed bundles, Don't need to explicitly set currently
+            else:
+                self.constants.sip_status = False  # Unsigned kexts
+                self.constants.secure_status = False  # Modified root volume
+                # self.constants.disable_amfi = False  # Signed bundles, Don't need to explicitly set currently
+        if model == "MacBook8,1":
+            # MacBook8,1 has an odd bug where it cannot install Monterey with Minimal spoofing
+            self.constants.serial_settings == "Moderate"
 
     def build_opencore(self):
-        Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).build_opencore()
+        Build.BuildOpenCore(self.constants.custom_model or self.constants.computer.real_model, self.constants).build_opencore()
 
     def install_opencore(self):
-        Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).copy_efi()
+        Build.BuildOpenCore(self.constants.custom_model or self.constants.computer.real_model, self.constants).copy_efi()
 
     def change_model(self):
         Utilities.cls()
         Utilities.header(["Select Different Model"])
-        print("""
+        print(
+            """
 Tip: Run the following command on the target machine to find the model identifier:
 
 system_profiler SPHardwareDataType | grep 'Model Identifier'
-    """)
+    """
+        )
         self.constants.custom_model = input("Please enter the model identifier of the target machine: ").strip()
         if self.constants.custom_model not in ModelArray.SupportedSMBIOS:
-            print(f"""
+            print(
+                f"""
 {self.constants.custom_model} is not a valid SMBIOS Identifier for macOS {self.constants.os_support}!
-            """)
+"""
+            )
             print_models = input(f"Print list of valid options for macOS {self.constants.os_support}? (y/n)")
-            if print_models in {"y", "Y", "yes", "Yes"}:
+            if print_models.lower() in {"y", "yes"}:
                 print("\n".join(ModelArray.SupportedSMBIOS))
                 input("\nPress [ENTER] to continue")
+        else:
+            self.set_defaults(self.constants.custom_model, False)
 
     def patcher_settings(self):
         response = None
         while not (response and response == -1):
-            title = [
+            title = ["Adjust Patcher Settings"]
-                "Adjust Patcher Settings"
-            ]
             menu = Utilities.TUIMenu(title, "Please select an option: ", auto_number=True, top_level=True)
             options = [
-                [f"Enable Verbose Mode:\t\tCurrently {self.constants.verbose_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_verbose],
+                [f"Enable Verbose Mode:\t\tCurrently {self.constants.verbose_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_verbose],
-                [f"Enable OpenCore DEBUG:\t\tCurrently {self.constants.opencore_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_oc],
+                [f"Enable OpenCore DEBUG:\t\tCurrently {self.constants.opencore_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_oc],
-                [f"Enable Kext DEBUG:\t\t\tCurrently {self.constants.kext_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_kext],
+                [f"Enable Kext DEBUG:\t\t\tCurrently {self.constants.kext_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_kext],
-                [f"Set ShowPicker Mode:\t\tCurrently {self.constants.showpicker}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_showpicker],
+                [f"Set ShowPicker Mode:\t\tCurrently {self.constants.showpicker}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_showpicker],
-                [f"Set Vault Mode:\t\t\tCurrently {self.constants.vault}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_vault],
+                [f"Set Vault Mode:\t\t\tCurrently {self.constants.vault}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_vault],
-                [f"Allow FireWire Boot:\t\tCurrently {self.constants.firewire_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_firewire],
+                [f"Allow FireWire Boot:\t\tCurrently {self.constants.firewire_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).allow_firewire],
-                [f"Allow NVMe Boot:\t\t\tCurrently {self.constants.nvme_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_nvme],
+                [f"Allow NVMe Boot:\t\t\tCurrently {self.constants.nvme_boot}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).allow_nvme],
-                [f"Enable TeraScale 2 Acceleration:\tCurrently {self.constants.terscale_2_patch}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).enable_terascale],
+                [
-                [f"Disable AMFI:\t\t\tCurrently {self.constants.disable_amfi}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).set_amfi],
+                    f"Enable TeraScale 2 Acceleration:\tCurrently {self.constants.terascale_2_patch}",
-                [f"Set SIP and SecureBootModel:\tSIP: {self.constants.sip_status} SBM: {self.constants.secure_status}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_sip],
+                    CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).enable_terascale,
-                [f"Allow OpenCore on native Models:\tCurrently {self.constants.allow_oc_everywhere}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_native_models],
+                ],
-                [f"Advanced Patch Settings, for developers only", self.advanced_patcher_settings],
+                [f"Disable AMFI:\t\t\tCurrently {self.constants.disable_amfi}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).set_amfi],
+                [
+                    f"Set SIP and SecureBootModel:\tSIP: {self.constants.sip_status} SBM: {self.constants.secure_status}",
+                    CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_sip,
+                ],
+                [
+                    f"Allow OpenCore on native Models:\tCurrently {self.constants.allow_oc_everywhere}",
+                    CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).allow_native_models,
+                ],
+                ["Advanced Patch Settings, for developers only", self.advanced_patcher_settings],
             ]
 
             for option in options:
@@ -126,21 +139,20 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
     def advanced_patcher_settings(self):
         response = None
         while not (response and response == -1):
-            title = [
+            title = ["Adjust Advanced Patcher Settings, for developers ONLY"]
-                "Adjust Advanced Patcher Settings, for developers ONLY"
-            ]
             menu = Utilities.TUIMenu(title, "Please select an option: ", auto_number=True, top_level=True)
             options = [
-                [f"Assume Metal GPU Always:\t\tCurrently {self.constants.imac_vendor}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_metal],
+                [f"Assume Metal GPU Always:\t\tCurrently {self.constants.imac_vendor}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_metal],
-                #[f"Assume Upgraded Wifi Always:\tCurrently {self.constants.wifi_build}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_wifi],
+                [f"Set SMBIOS Mode:\t\t\tCurrently {self.constants.serial_settings}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).change_serial],
-                [f"Set SMBIOS Mode:\t\t\tCurrently {self.constants.serial_settings}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_serial],
+                [f"DRM Preferences:\t\t\tCurrently {self.constants.drm_support}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).drm_setting],
-                [f"DRM Preferences:\t\t\tCurrently {self.constants.drm_support}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).drm_setting],
+                [f"Set Generic Bootstrap:\t\tCurrently {self.constants.boot_efi}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).bootstrap_setting],
-                [f"Set Generic Bootstrap:\t\tCurrently {self.constants.boot_efi}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).bootstrap_setting],
+                [
-                #[f"Assume Legacy GPU:\t\t\tCurrently {self.constants.assume_legacy}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).force_accel_setting],
+                    f"Disable CPU Friend:\t\t\tCurrently {self.constants.disallow_cpufriend}",
-                [f"Disable CPU Friend:\t\t\tCurrently {self.constants.disallow_cpufriend}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).disable_cpufriend],
+                    CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).disable_cpufriend,
-                [f"Override SMBIOS Spoof:\t\tCurrently {self.constants.override_smbios}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).set_smbios],
+                ],
-                [f"Set Custom name {self.constants.custom_cpu_model_value}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).custom_cpu],
+                [f"Override SMBIOS Spoof:\t\tCurrently {self.constants.override_smbios}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).set_smbios],
-                [f"Set SeedUtil Status", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).set_seedutil],
+                [f"Set Custom name {self.constants.custom_cpu_model_value}", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).custom_cpu],
+                ["Set SeedUtil Status", CliMenu.MenuOptions(self.constants.custom_model or self.computer.real_model, self.constants).set_seedutil],
             ]
 
             for option in options:
@@ -149,8 +161,11 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
             response = menu.start()
 
     def credits(self):
-        Utilities.TUIOnlyPrint(["Credits"], "Press [Enter] to go back.\n",
+        Utilities.TUIOnlyPrint(
-                               ["""Many thanks to the following:
+            ["Credits"],
+            "Press [Enter] to go back.\n",
+            [
+                """Many thanks to the following:
 
   - Acidanthera:\tOpenCore, kexts and other tools
   - Khronokernel:\tWriting and maintaining this patcher
@@ -158,7 +173,9 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
   - ASentientBot:\tLegacy Acceleration Patches
   - Ausdauersportler:\tLinking fixes for SNBGraphicsFB and AMDX3000
   - Syncretic:\t\tAAAMouSSE and telemetrap
-  - cdf:\t\tNightShiftEnabler and Innie"""]).start()
+  - cdf:\t\tNightShiftEnabler and Innie"""
+            ],
+        ).start()
 
     def PatchVolume(self):
         Utilities.cls()
@@ -184,6 +201,8 @@ B. Exit
         """
         monterey = """Patches Root volume to fix misc issues such as:
 
+- Graphics Acceleration
+  - Intel: Ivy Bridge (4000 series iGPUs)
 - Basic Framebuffer and brightness Control (No acceleration)
   - Nvidia: Tesla - Fermi (8000-500 series)
   - Intel: Ironlake - Sandy Bridge
@@ -201,56 +220,68 @@ Supported Options:
 2. Unpatch System Volume (Experimental)
 B. Exit
         """
-        if self.constants.detected_os > self.constants.big_sur:
+
+        default = """
+This OS has no root patches available to apply, please ensure you're patching a booted
+install that requires root patches such as macOS Big Sur or Monterey
+
+Supported Options:
+
+B. Exit
+        """
+        no_patch = False
+        if self.constants.detected_os == self.constants.monterey:
             print(monterey)
-        else:
+        elif self.constants.detected_os == self.constants.big_sur:
             print(big_sur)
+        else:
+            print(default)
+            no_patch = True
         change_menu = input("Patch System Volume?: ")
-        if change_menu == "1":
+        if no_patch is not True and change_menu == "1":
-            SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_patch()
+            SysPatch.PatchSysVolume(self.constants.custom_model or self.computer.real_model, self.constants).start_patch()
-        elif change_menu == "2":
+        elif no_patch is not True and change_menu == "2":
-            SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_unpatch()
+            SysPatch.PatchSysVolume(self.constants.custom_model or self.computer.real_model, self.constants).start_unpatch()
         else:
             print("Returning to main menu")
 
     def main_menu(self):
         response = None
-        ModelArray.SupportedSMBIOS = ModelArray.SupportedSMBIOS12
         while not (response and response == -1):
             title = [
                 f"OpenCore Legacy Patcher v{self.constants.patcher_version}",
-                f"Selected Model: {self.constants.custom_model or self.current_model}",
+                f"Selected Model: {self.constants.custom_model or self.computer.real_model}",
             ]
 
-            if (self.constants.custom_model or self.current_model) not in ModelArray.SupportedSMBIOS and self.constants.allow_oc_everywhere is False:
+            if (self.constants.custom_model or self.computer.real_model) not in ModelArray.SupportedSMBIOS and self.constants.allow_oc_everywhere is False:
                 in_between = [
-                    'Your model is not supported by this patcher for running unsupported OSes!',
+                    "Your model is not supported by this patcher for running unsupported OSes!",
-                    '',
+                    "",
-                    'If you plan to create the USB for another machine, please select the "Change Model" option in the menu.'
+                    'If you plan to create the USB for another machine, please select the "Change Model" option in the menu.',
                 ]
-            elif not self.constants.custom_model and self.current_model == "iMac7,1" and \
+            elif not self.constants.custom_model and self.computer.real_model == "iMac7,1" and "SSE4.1" not in self.computer.cpu.flags:
-                    DeviceProbe.pci_probe().cpu_feature("SSE4.1") is False:
                 in_between = [
-                    'Your model requires a CPU upgrade to a CPU supporting SSE4.1+ to be supported by this patcher!',
+                    "Your model requires a CPU upgrade to a CPU supporting SSE4.1+ to be supported by this patcher!",
-                    '',
+                    "",
-                    f'If you plan to create the USB for another {self.current_model} with SSE4.1+, please select the "Change Model" option in the menu.'
+                    f'If you plan to create the USB for another {self.computer.real_model} with SSE4.1+, please select the "Change Model" option in the menu.',
                 ]
             elif self.constants.custom_model == "iMac7,1":
-                in_between = ["This model is supported",
+                in_between = ["This model is supported", "However please ensure the CPU has been upgraded to support SSE4.1+"]
-                              "However please ensure the CPU has been upgraded to support SSE4.1+"
-                              ]
             else:
                 in_between = ["This model is supported"]
 
             menu = Utilities.TUIMenu(title, "Please select an option: ", in_between=in_between, auto_number=True, top_level=True)
 
             options = (
-                [["Build OpenCore", self.build_opencore]] if ((self.constants.custom_model or self.current_model) in ModelArray.SupportedSMBIOS) or self.constants.allow_oc_everywhere is True else []) + [
+                [["Build OpenCore", self.build_opencore]]
+                if ((self.constants.custom_model or self.computer.real_model) in ModelArray.SupportedSMBIOS) or self.constants.allow_oc_everywhere is True
+                else []
+            ) + [
                 ["Install OpenCore to USB/internal drive", self.install_opencore],
                 ["Post-Install Volume Patch", self.PatchVolume],
                 ["Change Model", self.change_model],
                 ["Patcher Settings", self.patcher_settings],
-                ["Credits", self.credits]
+                ["Credits", self.credits],
             ]
 
             for option in options:

Resources/Build.py

@@ -3,6 +3,8 @@
 from __future__ import print_function
 
 import binascii
+import copy
+import pickle
 import plistlib
 import shutil
 import subprocess
@@ -12,7 +14,7 @@ import ast
 from pathlib import Path
 from datetime import date
 
-from Resources import Constants, ModelArray, PCIIDArray, Utilities, DeviceProbe
+from Resources import Constants, ModelArray, Utilities, device_probe
 
 
 def human_fmt(num):
@@ -34,6 +36,9 @@ class BuildOpenCore:
         self.model = model
         self.config = None
         self.constants: Constants.Constants = versions
+        self.computer = self.constants.computer
+
+        self.gfx0_path = None
 
     def smbios_set(self):
         print("- Setting macOS Monterey Supported SMBIOS")
@@ -83,14 +88,14 @@ class BuildOpenCore:
         # Additionally, APFS bit(19) flipped
         # https://github.com/acidanthera/OpenCorePkg/blob/0.6.9/Include/Apple/IndustryStandard/AppleFeatures.h#L136
         if model == "iMac7,1":
-            fw_feature = b'\x07\x14\x08\xc0\x00\x00\x00\x00'
+            fw_feature = b"\x07\x14\x08\xc0\x00\x00\x00\x00"
-            fw_mask = b'\xff\x1f\x08\xc0\x00\x00\x00\x00'
+            fw_mask = b"\xff\x1f\x08\xc0\x00\x00\x00\x00"
         elif model in ["MacPro4,1", "Xserve3,1"]:
-            fw_feature = b'7\xf5\t\xe0\x00\x00\x00\x00'
+            fw_feature = b"7\xf5\t\xe0\x00\x00\x00\x00"
-            fw_mask = b'7\xff\x0b\xc0\x00\x00\x00\x00'
+            fw_mask = b"7\xff\x0b\xc0\x00\x00\x00\x00"
         else:
-            fw_feature = b'\x03\x14\x08\xc0\x00\x00\x00\x00'
+            fw_feature = b"\x03\x14\x08\xc0\x00\x00\x00\x00"
-            fw_mask = b'\xff\x3f\x08\xc0\x00\x00\x00\x00'
+            fw_mask = b"\xff\x3f\x08\xc0\x00\x00\x00\x00"
         return fw_feature, fw_mask
 
     def build_efi(self):
@@ -126,6 +131,9 @@ class BuildOpenCore:
         self.config["#Revision"]["Build-Version"] = f"{self.constants.patcher_version} - {date.today()}"
         if not self.constants.custom_model:
             self.config["#Revision"]["Build-Type"] = "OpenCore Built on Target Machine"
+            computer_copy = copy.copy(self.computer)
+            computer_copy.ioregistry = None
+            self.config["#Revision"]["Hardware-Probe"] = pickle.dumps(computer_copy)
         else:
             self.config["#Revision"]["Build-Type"] = "OpenCore Built for External Machine"
         self.config["#Revision"]["OpenCore-Version"] = f"{self.constants.opencore_version} - {self.constants.opencore_build} - {self.constants.opencore_commit}"
@@ -138,13 +146,23 @@ class BuildOpenCore:
             ("WhateverGreen.kext", self.constants.whatevergreen_version, self.constants.whatevergreen_path, lambda: self.constants.allow_oc_everywhere is False),
             ("RestrictEvents.kext", self.constants.restrictevents_version, self.constants.restrictevents_path, lambda: self.model in ModelArray.MacPro71),
             ("RestrictEvents.kext", self.constants.restrictevents_mbp_version, self.constants.restrictevents_mbp_path, lambda: self.model in ["MacBookPro6,1", "MacBookPro6,2", "MacBookPro9,1"]),
-            ("NightShiftEnabler.kext", self.constants.nightshift_version, self.constants.nightshift_path, lambda: self.model in ModelArray.NightShift and self.constants.allow_oc_everywhere is False and self.constants.serial_settings == "Minimal"),
+            (
+                "NightShiftEnabler.kext",
+                self.constants.nightshift_version,
+                self.constants.nightshift_path,
+                lambda: self.model in ModelArray.NightShift and self.constants.allow_oc_everywhere is False and self.constants.serial_settings == "Minimal",
+            ),
             ("SMC-Spoof.kext", self.constants.smcspoof_version, self.constants.smcspoof_path, lambda: self.constants.allow_oc_everywhere is False),
             # CPU patches
             ("AppleMCEReporterDisabler.kext", self.constants.mce_version, self.constants.mce_path, lambda: self.model in ModelArray.DualSocket),
             ("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path, lambda: self.model in ModelArray.SSEEmulator),
             ("telemetrap.kext", self.constants.telemetrap_version, self.constants.telemetrap_path, lambda: self.model in ModelArray.MissingSSE42),
-            ("CPUFriend.kext", self.constants.cpufriend_version, self.constants.cpufriend_path, lambda: self.model not in ["iMac7,1", "Xserve2,1"] and self.constants.allow_oc_everywhere is False and self.constants.disallow_cpufriend is False),
+            (
+                "CPUFriend.kext",
+                self.constants.cpufriend_version,
+                self.constants.cpufriend_path,
+                lambda: self.model not in ["iMac7,1", "Xserve2,1"] and self.constants.allow_oc_everywhere is False and self.constants.disallow_cpufriend is False,
+            ),
             # Ethernet patches
             ("nForceEthernet.kext", self.constants.nforce_version, self.constants.nforce_path, lambda: self.model in ModelArray.EthernetNvidia),
             ("MarvelYukonEthernet.kext", self.constants.marvel_version, self.constants.marvel_path, lambda: self.model in ModelArray.EthernetMarvell),
@@ -162,87 +180,51 @@ class BuildOpenCore:
         if self.constants.allow_oc_everywhere is False:
             self.get_item_by_kv(self.config["Kernel"]["Patch"], "Identifier", "com.apple.driver.AppleSMC")["Enabled"] = True
 
-
         if not self.constants.custom_model and (self.constants.allow_oc_everywhere is True or self.model in ModelArray.MacPro71):
             # Use Innie's same logic:
             # https://github.com/cdf/Innie/blob/v1.3.0/Innie/Innie.cpp#L90-L97
-            storage_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+            for i, controller in enumerate(self.computer.storage):
-            storage_devices = [i for i in storage_devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_sata) or i["class-code"] == binascii.unhexlify(self.constants.classcode_nvme)]
+                print(f"- Fixing PCIe Storage Controller ({i + 1}) reporting")
-            storage_path_gfx: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+                if controller.pci_path:
-            try:
+                    self.config["DeviceProperties"]["Add"][controller.pci_path] = {"built-in": 1}
-                x = 1
+                else:
-                for i in storage_devices:
+                    print(f"- Failed to find Device path for PCIe Storage Controller {i}, falling back to Innie")
-                    storage_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
-                    storage_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
-                    print(f'- Fixing PCIe Storage Controller ({x}) reporting')
-                    try:
-                        storage_path = [line.strip().split("= ", 1)[1] for line in storage_path_gfx.split("\n") if f'{storage_vendor}:{storage_device}'.lower() in line.strip()][0]
-                        self.config["DeviceProperties"]["Add"][storage_path] = { "built-in": 1}
-                    except IndexError:
-                        print(f"- Failed to find Device path for PCIe Storage Controller {x}, falling back to Innie")
                     if self.get_kext_by_bundle_path("Innie.kext")["Enabled"] is False:
                         self.enable_kext("Innie.kext", self.constants.innie_version, self.constants.innie_path)
-                    x = x + 1
+            if not self.computer.storage:
-            except ValueError:
+                print("- No PCIe Storage Controllers found to fix")
-                print("- No PCIe Storage Controllers found to fix(V)")
-            except IndexError:
-                print("- No PCIe Storage Controllers found to fix(I)")
 
         if not self.constants.custom_model:
-            nvme_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+            nvme_devices = [i for i in self.computer.storage if isinstance(i, device_probe.NVMeController)]
-            nvme_devices = [i for i in nvme_devices if i.get("IORegistryEntryChildren", None) and i["vendor-id"] != binascii.unhexlify("6B100000") and i["IORegistryEntryChildren"][0]["IORegistryEntryName"] == "IONVMeController"]
+            for i, controller in enumerate(nvme_devices):
-            try:
+                print(f"- Found 3rd Party NVMe SSD ({i + 1}): {Utilities.friendly_hex(controller.vendor_id)}:{Utilities.friendly_hex(controller.device_id)}")
-                x = 1
+                self.config["#Revision"][f"Hardware-NVMe-{i}"] = f"{Utilities.friendly_hex(controller.vendor_id)}:{Utilities.friendly_hex(controller.device_id)}"
-                for i in nvme_devices:
+
-                    nvme_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
-                    nvme_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
-                    print(f'- Found 3rd Party NVMe SSD ({x}): {nvme_vendor}:{nvme_device}')
-                    nvme_aspm = i["pci-aspm-default"]
-                    try:
-                        nvme_acpi = i["acpi-path"]
-                        nvme_acpi = DeviceProbe.pci_probe().acpi_strip(nvme_acpi)
-                    except KeyError:
-                        print(f"- No ACPI entry found for NVMe SSD ({x})")
-                        nvme_acpi = ""
                 # Disable Bit 0 (L0s), enable Bit 1 (L1)
-                    if not isinstance(nvme_aspm, int):
+                nvme_aspm = (controller.aspm & (~3)) | 2
-                        nvme_aspm = int.from_bytes(nvme_aspm, byteorder='little')
+
-                    nvme_aspm = (nvme_aspm & (~3)) | 2
+                if controller.pci_path:
-                    #nvme_aspm &= ~1  # Turn off bit 1
+                    print(f"- Found NVMe ({i}) at {controller.pci_path}")
-                    #nvme_aspm |= 2  # Turn on bit 2
+                    self.config["DeviceProperties"]["Add"].setdefault(controller.pci_path, {})["pci-aspm-default"] = nvme_aspm
-                    self.config["#Revision"][f"Hardware-NVMe-{x}"] = f'{nvme_vendor}:{nvme_device}'
+                    self.config["DeviceProperties"]["Add"][controller.pci_path.rpartition("/")[0]] = {"pci-aspm-default": nvme_aspm}
-                    try:
+                else:
-                        nvme_path = DeviceProbe.pci_probe().deviceproperty_probe(nvme_vendor, nvme_device, nvme_acpi)
-                        if nvme_path == "":
-                            raise IndexError
-                        nvme_path_parent = DeviceProbe.pci_probe().device_property_parent(nvme_path)
-                        print(f"- Found NVMe ({x}) at {nvme_path}")
-                        self.config["DeviceProperties"]["Add"][nvme_path] = {"pci-aspm-default": nvme_aspm, "built-in": 1}
-                        self.config["DeviceProperties"]["Add"][nvme_path_parent] = {"pci-aspm-default": nvme_aspm}
-                    except IndexError:
                     if "-nvmefaspm" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
                         print("- Falling back to -nvmefaspm")
                         self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -nvmefaspm"
+
                 if self.get_kext_by_bundle_path("NVMeFix.kext")["Enabled"] is False:
                     self.enable_kext("NVMeFix.kext", self.constants.nvmefix_version, self.constants.nvmefix_path)
-                    x = x + 1
+
-            except ValueError:
+            if not nvme_devices:
-                print("- No 3rd Party NVMe drive found(V)")
+                print("- No 3rd Party NVMe drives found")
-            except IndexError:
-                print("- No 3rd Party NVMe drive found(I)")
 
         def wifi_fake_id(self):
-            default_path = True
             self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
             # self.get_kext_by_bundle_path("AirportBrcmFixup.kext/Contents/PlugIns/AirPortBrcmNIC_Injector.kext")["Enabled"] = True
-            if not self.constants.custom_model:
+            if not self.constants.custom_model and self.computer.wifi and self.computer.wifi.pci_path:
-                arpt_path = DeviceProbe.pci_probe().deviceproperty_probe(wifi_vendor, wifi_device, wifi_acpi)
+                arpt_path = self.computer.wifi.pci_path
-                if arpt_path:
                 print(f"- Found ARPT device at {arpt_path}")
-                    default_path = False
             else:
-                    default_path = True
-            if default_path is True:
                 if self.model in ModelArray.nvidiaHDEF:
                     # Nvidia chipsets all have the same path to ARPT
                     arpt_path = "PciRoot(0x0)/Pci(0x15,0x0)/Pci(0x0,0x0)"
@@ -257,42 +239,46 @@ class BuildOpenCore:
                     # iMac11,x-12,x also apply
                     arpt_path = "PciRoot(0x0)/Pci(0x1C,0x1)/Pci(0x0,0x0)"
                 print(f"- Using known DevicePath {arpt_path}")
-            print("- Applying fake ID for WiFi")
+            print(f"- Applying fake ID for WiFi, setting Country Code: {self.computer.wifi.country_code}")
-            self.config["DeviceProperties"]["Add"][arpt_path] = {"device-id": binascii.unhexlify("ba430000"), "compatible": "pci14e4,43ba"}
+            self.config["DeviceProperties"]["Add"][arpt_path] = {"device-id": binascii.unhexlify("ba430000"), "compatible": "pci14e4,43ba", "brcmfx-country": self.computer.wifi.country_code}
 
         # WiFi patches
         # TODO: -a is not supported in Lion and older, need to add proper fix
         if self.constants.detected_os > self.constants.lion and not self.constants.custom_model:
-            wifi_vendor,wifi_device,wifi_ioname,wifi_acpi = DeviceProbe.pci_probe().wifi_probe()
+            if self.computer.wifi:
-            if wifi_vendor:
+                print(f"- Found Wireless Device {Utilities.friendly_hex(self.computer.wifi.vendor_id)}:{Utilities.friendly_hex(self.computer.wifi.device_id)}")
-                print(f"- Found Wireless Device {wifi_vendor}:{wifi_device} ({wifi_ioname})")
+                self.config["#Revision"]["Hardware-Wifi"] = f"{Utilities.friendly_hex(self.computer.wifi.vendor_id)}:{Utilities.friendly_hex(self.computer.wifi.device_id)}"
-                self.config["#Revision"]["Hardware-Wifi"] = f"{wifi_vendor}:{wifi_device} ({wifi_ioname})"
         else:
-            wifi_vendor = ""
             print("- Unable to run Wireless hardware detection")
+
         if self.constants.wifi_build is True:
             print("- Skipping Wifi patches on request")
-        elif not self.constants.custom_model and wifi_vendor:
+        elif not self.constants.custom_model and self.computer.wifi:
-            if wifi_vendor == self.constants.pci_broadcom:
+            if isinstance(self.computer.wifi, device_probe.Broadcom):
                 # This works around OCLP spoofing the Wifi card and therefore unable to actually detect the correct device
-                if wifi_device in PCIIDArray.broadcom_ids().BCM4360Wifi and wifi_ioname not in ["pci14e4,4353", "pci14e4,4331"]:
+                if self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirportBrcmNIC:
                     self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
-                elif wifi_ioname in ["pci14e4,4353", "pci14e4,4331"] or wifi_device in PCIIDArray.broadcom_ids().BCM94331Wifi:
+                    print(f"- Setting Wireless Card's Country Code: {self.computer.wifi.country_code}")
+                    if not self.constants.custom_model and self.computer.wifi and self.computer.wifi.pci_path:
+                        arpt_path = self.computer.wifi.pci_path
+                        print(f"- Found ARPT device at {arpt_path}")
+                        self.config["DeviceProperties"]["Add"][arpt_path] = {"brcmfx-country": self.computer.wifi.country_code}
+                    else:
+                        self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += f" brcmfx-country={self.computer.wifi.country_code}"
+                elif self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirPortBrcm4360:
                     wifi_fake_id(self)
-                elif wifi_device in PCIIDArray.broadcom_ids().BCM94322Wifi:
+                elif self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirPortBrcm4331:
                     self.enable_kext("IO80211Mojave.kext", self.constants.io80211mojave_version, self.constants.io80211mojave_path)
                     self.get_kext_by_bundle_path("IO80211Mojave.kext/Contents/PlugIns/AirPortBrcm4331.kext")["Enabled"] = True
-                elif wifi_device in PCIIDArray.broadcom_ids().BCM94328Wifi:
+                elif self.computer.wifi.chipset == device_probe.Broadcom.Chipsets.AirPortBrcm43224:
                     self.enable_kext("corecaptureElCap.kext", self.constants.corecaptureelcap_version, self.constants.corecaptureelcap_path)
                     self.enable_kext("IO80211ElCap.kext", self.constants.io80211elcap_version, self.constants.io80211elcap_path)
                     self.get_kext_by_bundle_path("IO80211ElCap.kext/Contents/PlugIns/AppleAirPortBrcm43224.kext")["Enabled"] = True
-            elif wifi_vendor == self.constants.pci_atheros and wifi_device in PCIIDArray.atheros_ids().AtherosWifi:
+            elif isinstance(self.computer.wifi, device_probe.Atheros) and self.computer.wifi.chipset == device_probe.Atheros.Chipsets.AirPortAtheros40:
                 self.enable_kext("IO80211HighSierra.kext", self.constants.io80211high_sierra_version, self.constants.io80211high_sierra_path)
                 self.get_kext_by_bundle_path("IO80211HighSierra.kext/Contents/PlugIns/AirPortAtheros40.kext")["Enabled"] = True
         else:
-            if self.model in ["iMac14,1", "iMac14,2", "iMac14,3"]:
+            if self.model in ModelArray.WifiBCM94331:
-                self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
-            elif self.model in ModelArray.WifiBCM94331:
                 wifi_fake_id(self)
             elif self.model in ModelArray.WifiBCM94322:
                 self.enable_kext("IO80211Mojave.kext", self.constants.io80211mojave_version, self.constants.io80211mojave_path)
@@ -304,6 +290,10 @@ class BuildOpenCore:
             elif self.model in ModelArray.WifiAtheros:
                 self.enable_kext("IO80211HighSierra.kext", self.constants.io80211high_sierra_version, self.constants.io80211high_sierra_path)
                 self.get_kext_by_bundle_path("IO80211HighSierra.kext/Contents/PlugIns/AirPortAtheros40.kext")["Enabled"] = True
+            else:
+                self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
+                print(f"- Setting Wireless Card's Country Code: {self.computer.wifi.country_code}")
+                self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += f" brcmfx-country={self.computer.wifi.country_code}"
 
         # CPUFriend
         pp_map_path = Path(self.constants.platform_plugin_plist_path) / Path(f"{self.model}/Info.plist")
@@ -335,13 +325,12 @@ class BuildOpenCore:
         usb_map_path = Path(self.constants.plist_folder_path) / Path("AppleUSBMaps/Info.plist")
         # iMac7,1 kernel panics with USB map installed, remove for time being until properly debugged
         if usb_map_path.exists() and self.constants.allow_oc_everywhere is False and self.model not in ["iMac7,1", "Xserve2,1"]:
-            print(f"- Adding USB-Map.kext")
+            print("- Adding USB-Map.kext")
             Path(self.constants.map_kext_folder).mkdir()
             Path(self.constants.map_contents_folder).mkdir()
             shutil.copy(usb_map_path, self.constants.map_contents_folder)
             self.get_kext_by_bundle_path("USB-Map.kext")["Enabled"] = True
 
-
         if self.constants.allow_oc_everywhere is False:
             if self.model == "MacBookPro9,1":
                 print("- Adding AppleMuxControl Override")
@@ -371,28 +360,33 @@ class BuildOpenCore:
         # AGPM Patch
         if self.model in ModelArray.DualGPUPatch:
             print("- Adding dual GPU patch")
-            if not self.constants.custom_model:
+            if not self.constants.custom_model and self.computer.dgpu and self.computer.dgpu.pci_path:
-                dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+                self.gfx0_path = self.computer.dgpu.pci_path
-                self.gfx0_path = DeviceProbe.pci_probe().deviceproperty_probe(dgpu_vendor,dgpu_device,dgpu_acpi)
-                if self.gfx0_path == "":
-                    print("- Failed to find GFX0 Device path, falling back on known logic")
-                    self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
-                else:
                 print(f"- Found GFX0 Device Path: {self.gfx0_path}")
             else:
+                if not self.constants.custom_model:
+                    print("- Failed to find GFX0 Device path, falling back on known logic")
                 self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
+
             if self.model in ModelArray.IntelNvidiaDRM and self.constants.drm_support is True:
                 print("- Prioritizing DRM support over Intel QuickSync")
                 self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696", "shikigva": 256}
-                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")}
+                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
+                    "name": binascii.unhexlify("23646973706C6179"),
+                    "IOName": "#display",
+                    "class-code": binascii.unhexlify("FFFFFFFF"),
+                }
             else:
                 self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696"}
 
         if self.model in ["iMac13,1", "iMac13,2", "iMac13,3"]:
-            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+            if self.computer.dgpu:
-            if dgpu_vendor:
                 print("- Fixing sleep support in macOS 12")
-                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")}
+                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
+                    "name": binascii.unhexlify("23646973706C6179"),
+                    "IOName": "#display",
+                    "class-code": binascii.unhexlify("FFFFFFFF"),
+                }
 
         # Audio Patch
         if self.model in ModelArray.LegacyAudio:
@@ -400,9 +394,17 @@ class BuildOpenCore:
             hdef_path = "PciRoot(0x0)/Pci(0x8,0x0)" if self.model in ModelArray.nvidiaHDEF else "PciRoot(0x0)/Pci(0x1b,0x0)"
             # In AppleALC, MacPro3,1's original layout is already in use, forcing layout 13 instead
             if self.model == "MacPro3,1":
-                self.config["DeviceProperties"]["Add"][hdef_path] = {"apple-layout-id": 90, "use-apple-layout-id": 1, "alc-layout-id": 13, }
+                self.config["DeviceProperties"]["Add"][hdef_path] = {
+                    "apple-layout-id": 90,
+                    "use-apple-layout-id": 1,
+                    "alc-layout-id": 13,
+                }
             else:
-                self.config["DeviceProperties"]["Add"][hdef_path] = {"apple-layout-id": 90, "use-apple-layout-id": 1, "use-layout-id": 1, }
+                self.config["DeviceProperties"]["Add"][hdef_path] = {
+                    "apple-layout-id": 90,
+                    "use-apple-layout-id": 1,
+                    "use-layout-id": 1,
+                }
 
         # Enable FireWire Boot Support
         if self.constants.firewire_boot is True and self.model not in ModelArray.NoFireWireSupport:
@@ -413,10 +415,11 @@ class BuildOpenCore:
             self.get_kext_by_bundle_path("IOFireWireFamily.kext/Contents/PlugIns/AppleFWOHCI.kext")["Enabled"] = True
 
         def backlight_path_detection(self):
+            if not self.constants.custom_model and self.computer.dgpu and self.computer.dgpu.pci_path:
+                self.gfx0_path = self.computer.dgpu.pci_path
+                print(f"- Found GFX0 Device Path: {self.gfx0_path}")
+            else:
                 if not self.constants.custom_model:
-                dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
-                self.gfx0_path = DeviceProbe.pci_probe().deviceproperty_probe(dgpu_vendor,dgpu_device,dgpu_acpi)
-                if self.gfx0_path == "":
                     print("- Failed to find GFX0 Device path, falling back on known logic")
                 if self.model in ["iMac11,1", "iMac11,3"]:
                     self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
@@ -424,33 +427,43 @@ class BuildOpenCore:
                     self.gfx0_path = "PciRoot(0x0)/Pci(0xc,0x0)/Pci(0x0,0x0)"
                 else:
                     self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
-                else:
-                    print(f"- Found GFX0 Device Path: {self.gfx0_path}")
-
-            else:
-                if self.model in ["iMac11,1", "iMac11,3"]:
-                    self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
-                elif self.model == "iMac10,1":
-                    self.gfx0_path = "PciRoot(0x0)/Pci(0xc,0x0)/Pci(0x0,0x0)"
-                else:
-                    self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
-                print(f"- Using known GFX0 path: {self.gfx0_path}")
-
 
         def nvidia_patch(self, backlight_path):
             self.constants.custom_mxm_gpu = True
             if self.model in ["iMac11,1", "iMac11,2", "iMac11,3", "iMac10,1"]:
                 print("- Adding Nvidia Brightness Control and DRM patches")
-                self.config["DeviceProperties"]["Add"][backlight_path] = {"applbkl": binascii.unhexlify("01000000"), "@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256, "agdpmod": "vit9696"}
+                self.config["DeviceProperties"]["Add"][backlight_path] = {
+                    "applbkl": binascii.unhexlify("01000000"),
+                    "@0,backlight-control": binascii.unhexlify("01000000"),
+                    "@0,built-in": binascii.unhexlify("01000000"),
+                    "shikigva": 256,
+                    "agdpmod": "vit9696",
+                }
                 if self.constants.custom_model and self.model == "iMac11,2":
                     # iMac11,2 can have either PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0) or PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)
                     # Set both properties when we cannot run hardware detection
-                    self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {"applbkl": binascii.unhexlify("01000000"), "@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256, "agdpmod": "vit9696"}
+                    self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {
+                        "applbkl": binascii.unhexlify("01000000"),
+                        "@0,backlight-control": binascii.unhexlify("01000000"),
+                        "@0,built-in": binascii.unhexlify("01000000"),
+                        "shikigva": 256,
+                        "agdpmod": "vit9696",
+                    }
             elif self.model in ["iMac12,1", "iMac12,2"]:
                 print("- Adding Nvidia Brightness Control and DRM patches")
-                self.config["DeviceProperties"]["Add"][backlight_path] = {"applbkl": binascii.unhexlify("01000000"), "@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256, "agdpmod": "vit9696"}
+                self.config["DeviceProperties"]["Add"][backlight_path] = {
+                    "applbkl": binascii.unhexlify("01000000"),
+                    "@0,backlight-control": binascii.unhexlify("01000000"),
+                    "@0,built-in": binascii.unhexlify("01000000"),
+                    "shikigva": 256,
+                    "agdpmod": "vit9696",
+                }
                 print("- Disabling unsupported iGPU")
-                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")}
+                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
+                    "name": binascii.unhexlify("23646973706C6179"),
+                    "IOName": "#display",
+                    "class-code": binascii.unhexlify("FFFFFFFF"),
+                }
             shutil.copy(self.constants.backlight_injector_path, self.constants.kexts_path)
             self.get_kext_by_bundle_path("BacklightInjector.kext")["Enabled"] = True
             self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
@@ -466,7 +479,11 @@ class BuildOpenCore:
                 self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {"shikigva": 80, "unfairgva": 1}
             if self.model in ["iMac12,1", "iMac12,2"]:
                 print("- Disabling unsupported iGPU")
-                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")}
+                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {
+                    "name": binascii.unhexlify("23646973706C6179"),
+                    "IOName": "#display",
+                    "class-code": binascii.unhexlify("FFFFFFFF"),
+                }
             elif self.model == "iMac10,1":
                 self.enable_kext("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path)
 
@@ -480,61 +497,54 @@ class BuildOpenCore:
                 nvidia_patch(self, self.gfx0_path)
             else:
                 print("- Failed to find vendor")
-        elif not self.constants.custom_model and self.model in ModelArray.LegacyGPU:
+        elif not self.constants.custom_model and self.model in ModelArray.LegacyGPU and self.computer.dgpu:
-            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+            print(f"- Detected dGPU: {Utilities.friendly_hex(self.computer.dgpu.vendor_id)}:{Utilities.friendly_hex(self.computer.dgpu.device_id)}")
-            if dgpu_vendor:
+            if self.computer.dgpu.arch in [
-                print(f"- Detected dGPU: {dgpu_vendor}:{dgpu_device}")
+                device_probe.AMD.Archs.Legacy_GCN,
-                if dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids):
+                device_probe.AMD.Archs.Polaris,
+                device_probe.AMD.Archs.Vega,
+                device_probe.AMD.Archs.Navi,
+            ]:
                 backlight_path_detection(self)
                 amd_patch(self, self.gfx0_path)
-                elif dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids:
+            elif self.computer.dgpu.arch == device_probe.NVIDIA.Archs.Kepler:
                 backlight_path_detection(self)
                 nvidia_patch(self, self.gfx0_path)
         if self.model in ModelArray.MacPro71:
             if not self.constants.custom_model:
-                mp_dgpu_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+                for i, device in enumerate(self.computer.gpus):
-                mp_dgpu_devices = [i for i in mp_dgpu_devices if i["class-code"] == binascii.unhexlify("00000300") or i["class-code"] == binascii.unhexlify("00800300")]
+                    print(f"- Found dGPU ({i + 1}): {Utilities.friendly_hex(device.vendor_id)}:{Utilities.friendly_hex(device.device_id)}")
-                mp_dgpu_devices_gfx: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+                    self.config["#Revision"][f"Hardware-MacPro-dGPU-{i + 1}"] = f"{Utilities.friendly_hex(device.vendor_id)}:{Utilities.friendly_hex(device.device_id)}"
-                try:
-                    x = 1
-                    for i in mp_dgpu_devices:
-                        mp_dgpu_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
-                        mp_dgpu_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
 
-                        print(f'- Found dGPU ({x}): {mp_dgpu_vendor}:{mp_dgpu_device}')
+                    if device.pci_path:
-                        self.config["#Revision"][f"Hardware-MacPro-dGPU-{x}"] = f'{mp_dgpu_vendor}:{mp_dgpu_device}'
+                        print(f"- Found dGPU ({i + 1}) at {device.pci_path}")
-
+                        if isinstance(device, device_probe.AMD):
-                        try:
-                            mp_dgpu_path = [line.strip().split("= ", 1)[1] for line in mp_dgpu_devices_gfx.split("\n") if f'{mp_dgpu_vendor}:{mp_dgpu_device}'.lower() in line.strip()][0]
-                            print(f"- Found dGPU ({x}) at {mp_dgpu_path}")
-                            if mp_dgpu_vendor == self.constants.pci_amd_ati:
                             print("- Adding Mac Pro, Xserve DRM patches")
-                                self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"shikigva": 128, "unfairgva": 1, "rebuild-device-tree": 1}
+                            self.config["DeviceProperties"]["Add"][device.pci_path] = {"shikigva": 128, "unfairgva": 1, "rebuild-device-tree": 1}
-                            elif mp_dgpu_vendor == self.constants.pci_nvidia:
+                        elif isinstance(device, device_probe.NVIDIA):
                             print("- Enabling Nvidia Output Patch")
-                                self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"rebuild-device-tree": 1}
+                            self.config["DeviceProperties"]["Add"][device.pci_path] = {"rebuild-device-tree": 1}
                             self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
                             self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
 
-                        except IndexError:
+                    else:
-                            print(f"- Failed to find Device path for NVMe {x}")
+                        print(f"- Failed to find Device path for dGPU {i + 1}")
-                            if mp_dgpu_vendor == self.constants.pci_amd_ati:
+                        if isinstance(device, device_probe.AMD):
                             print("- Adding Mac Pro, Xserve DRM patches")
-                                if "shikigva=128 unfairgva=1 -wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
+                            if "shikigva=128 unfairgva=1" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
                                 print("- Falling back to boot-args")
-                                    self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1 -wegtree"
+                                self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1" + (" -wegtree" if "-wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] else "")
-                            elif mp_dgpu_vendor == self.constants.pci_nvidia:
+                        elif isinstance(device, device_probe.NVIDIA):
                             print("- Enabling Nvidia Output Patch")
                             if "-wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
                                 print("- Falling back to boot-args")
                                 self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -wegtree"
                             self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
                             self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
-                        x = x + 1
+
-                except ValueError:
+                if not self.computer.gpus:
-                    print("- No socketed dGPU found")
-                except IndexError:
                     print("- No socketed dGPU found")
+
             else:
                 print("- Adding Mac Pro, Xserve DRM patches")
                 self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1 -wegtree"
@@ -590,8 +600,8 @@ class BuildOpenCore:
             # self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " msgbuf=1048576"
         if self.constants.opencore_debug is True:
             print("- Enabling DEBUG OpenCore")
-            self.config["Misc"]["Debug"]["Target"] = 67
+            self.config["Misc"]["Debug"]["Target"] = 0x43
-            self.config["Misc"]["Debug"]["DisplayLevel"] = 672151678018
+            self.config["Misc"]["Debug"]["DisplayLevel"] = 0x80000042
         if self.constants.showpicker is True:
             print("- Enabling ShowPicker")
             self.config["Misc"]["Boot"]["ShowPicker"] = True
@@ -739,7 +749,6 @@ class BuildOpenCore:
             cpu_config["IOKitPersonalities"]["CPUFriendDataProvider"]["cf-frequency-data"] = string_stuff
             plistlib.dump(cpu_config, Path(new_cpu_ls).open("wb"), sort_keys=True)
 
-
         if self.constants.allow_oc_everywhere is False:
             if self.model == "MacBookPro9,1":
                 new_amc_ls = Path(self.constants.amc_contents_folder) / Path("Info.plist")
@@ -754,10 +763,11 @@ class BuildOpenCore:
             if self.model in ModelArray.AGDPSupport:
                 new_agdp_ls = Path(self.constants.agdp_contents_folder) / Path("Info.plist")
                 agdp_config = plistlib.load(Path(new_agdp_ls).open("rb"))
-                agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"][self.spoofed_board] = agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"].pop(self.model)
+                agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"][self.spoofed_board] = agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"].pop(
+                    self.model
+                )
                 plistlib.dump(agdp_config, Path(new_agdp_ls).open("wb"), sort_keys=True)
 
-
     @staticmethod
     def get_item_by_kv(iterable, key, value):
         item = None
@@ -819,7 +829,7 @@ class BuildOpenCore:
                 zip_file.extractall(self.constants.oc_folder)
             item.unlink()
 
-        if self.constants.recovery_status == False:
+        if not self.constants.recovery_status:
             # Crashes in RecoveryOS for unknown reason
             for i in self.constants.build_path.rglob("__MACOSX"):
                 shutil.rmtree(i)
@@ -829,7 +839,7 @@ class BuildOpenCore:
     def sign_files(self):
         if self.constants.vault is True:
             print("- Vaulting EFI")
-            subprocess.run([self.constants.vault_path] + f"{self.constants.oc_folder}/".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+            subprocess.run([str(self.constants.vault_path), f"{self.constants.oc_folder}/"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
     def build_opencore(self):
         self.build_efi()
@@ -936,7 +946,7 @@ Please build OpenCore first!"""
             " without altering line endings",
         ]
 
-        if self.constants.detected_os > self.constants.yosemite and self.constants.recovery_status == False:
+        if self.constants.detected_os >= self.constants.el_capitan and not self.constants.recovery_status:
             result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         else:
             result = subprocess.run(f"diskutil mount {disk_identifier}s{response}".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -965,6 +975,19 @@ Please build OpenCore first!"""
         Utilities.header(["Copying OpenCore"])
 
         if mount_path.exists():
+            if (mount_path / Path("EFI/Microsoft")).exists():
+                print("- Found Windows Boot Loader")
+                print("\nWould you like to continue installing OpenCore?")
+                print("Installing OpenCore onto this drive may make Windows unbootable until OpenCore")
+                print("is removed from the partition")
+                print("We highly recommend users partition 200MB off their drive with Disk Utility")
+                print("    Name:\t\t OPENCORE")
+                print("    Format:\t FAT32")
+                print("    Size:\t\t 200MB")
+                choice = input("\nWould you like to still install OpenCore to this drive?(y/n): ")
+                if not choice in ["y", "Y", "Yes", "yes"]:
+                    subprocess.run(["diskutil", "umount", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                    return
             if (mount_path / Path("EFI/OC")).exists():
                 print("- Removing preexisting EFI/OC folder")
                 shutil.rmtree(mount_path / Path("EFI/OC"), onerror=rmtree_handler)
@@ -996,7 +1019,7 @@ Please build OpenCore first!"""
                 print("- Adding Internal Drive icon")
                 shutil.copy(self.constants.icon_path_internal, mount_path)
             print("- Cleaning install location")
-            if self.constants.recovery_status == False:
+            if not self.constants.recovery_status:
                 # RecoveryOS doesn't support dot_clean
                 # Remove dot_clean, requires full disk access
                 # subprocess.run(["dot_clean", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()

Resources/CliMenu.py

@@ -3,7 +3,7 @@
 from __future__ import print_function
 import subprocess
 
-from Resources import ModelArray, Constants, Utilities
+from Resources import Constants, Utilities
 
 
 class MenuOptions:
@@ -11,24 +11,6 @@ class MenuOptions:
         self.model = model
         self.constants: Constants.Constants = versions
 
-    def change_os(self):
-        Utilities.cls()
-        Utilities.header(["Select Patcher's Target OS"])
-        print(f"""
-Minimum Target:\t{self.constants.min_os_support}
-Maximum Target:\t{self.constants.max_os_support}
-Current target:\t{self.constants.os_support}
-        """)
-        temp_os_support = float(input("Please enter OS target: "))
-        if (self.constants.max_os_support < temp_os_support) or (temp_os_support < self.constants.min_os_support):
-            print("Unsupported entry")
-        else:
-            self.constants.os_support = temp_os_support
-        if temp_os_support == 11.0:
-            ModelArray.SupportedSMBIOS = ModelArray.SupportedSMBIOS11
-        elif temp_os_support == 12.0:
-            ModelArray.SupportedSMBIOS = ModelArray.SupportedSMBIOS12
-
     def change_verbose(self):
         Utilities.cls()
         Utilities.header(["Set Verbose mode"])
@@ -67,7 +49,8 @@ Current target:\t{self.constants.os_support}
     def change_metal(self):
         Utilities.cls()
         Utilities.header(["Assume Metal GPU Always in iMac"])
-        print("""This is for iMacs that have upgraded Metal GPUs, otherwise
+        print(
+            """This is for iMacs that have upgraded Metal GPUs, otherwise
 Patcher assumes based on stock configuration (ie. iMac10,x-12,x)
 
 Valid Options:
@@ -78,7 +61,8 @@ Valid Options:
 
 Note: Patcher will detect whether hardware has been upgraded regardless, this
 option is for those patching on a different machine or OCLP cannot detect.
-        """)
+        """
+        )
         change_menu = input("Set GPU Patch type(ie. 1): ")
         if change_menu == "1":
             self.constants.metal_build = False
@@ -92,26 +76,11 @@ option is for those patching on a different machine or OCLP cannot detect.
         else:
             print("Invalid option")
 
-    def change_wifi(self):
-        Utilities.cls()
-        Utilities.header(["Assume Upgraded Wifi Always"])
-        print("""This is for Macs with upgraded wifi cards(ie. BCM94360/2)
-
-Note: Patcher will detect whether hardware has been upgraded regardless, this
-option is for those patching on a different machine or cannot detect.
-        """)
-        change_menu = input("Enable Upgraded Wifi build algorithm?(y/n): ")
-        if change_menu in {"y", "Y", "yes", "Yes"}:
-            self.constants.wifi_build = True
-        elif change_menu in {"n", "N", "no", "No"}:
-            self.constants.wifi_build = False
-        else:
-            print("Invalid option")
-
     def change_serial(self):
         Utilities.cls()
         Utilities.header(["Set SMBIOS Mode"])
-        print("""This section is for setting how OpenCore generates the SMBIOS
+        print(
+            """This section is for setting how OpenCore generates the SMBIOS
 Recommended for adanced users who want control how serials are handled
 
 Valid options:
@@ -121,7 +90,8 @@ Valid options:
 3. Advanced:\tReplace entire SMBIOS and generate new serials
 
 Note: For new users we recommend leaving as default(1. Minimal)
-        """)
+        """
+        )
         change_menu = input("Set SMBIOS Mode(ie. 1): ")
         if change_menu == "1":
             self.constants.serial_settings = "Minimal"
@@ -135,10 +105,12 @@ Note: For new users we recommend leaving as default(1. Minimal)
     def change_showpicker(self):
         Utilities.cls()
         Utilities.header(["Set OpenCore Picker mode"])
-        print("""By default, OpenCore will show its boot picker each time on boot up,
+        print(
+            """By default, OpenCore will show its boot picker each time on boot up,
 however this can be disabled by default and be shown on command by repeatedly
 pressing the "Esc" key
-        """)
+        """
+        )
         change_menu = input("Show OpenCore Picker by default(y/n): ")
         if change_menu in {"y", "Y", "yes", "Yes"}:
             self.constants.showpicker = True
@@ -150,13 +122,15 @@ pressing the "Esc" key
     def change_vault(self):
         Utilities.cls()
         Utilities.header(["Set OpenCore Vaulting"])
-        print("""By default, this patcher will sign all your files and ensure none of the
+        print(
+            """By default, this patcher will sign all your files and ensure none of the
 contents can be tampered with. However for more advanced users, you may
 want to be able to freely edit the config.plist and files.
 
 Note: For security reasons, OpenShell will be disabled when Vault is set.
 
-        """)
+        """
+        )
         change_menu = input("Enable Vault(y/n): ")
         if change_menu in {"y", "Y", "yes", "Yes"}:
             self.constants.vault = True
@@ -168,7 +142,8 @@ Note: For security reasons, OpenShell will be disabled when Vault is set.
     def change_sip(self):
         Utilities.cls()
         Utilities.header(["Set SIP and SecureBootModel"])
-        print("""SIP and SecureBootModel are used to ensure proper OTA functionality,
+        print(
+            """SIP and SecureBootModel are used to ensure proper OTA functionality,
 however to patch the root volume both of these must be disabled.
 Only disable is absolutely necessary. SIP value = 0xFEF
 
@@ -179,7 +154,8 @@ Valid options:
 3. Disable SecureBootModel Only
 4. Disable Both
 
-        """)
+        """
+        )
         change_menu = input("Set SIP and SecureBootModel(ie. 1): ")
         if change_menu == "1":
             self.constants.sip_status = True
@@ -199,10 +175,12 @@ Valid options:
     def set_amfi(self):
         Utilities.cls()
         Utilities.header(["Disable AMFI"])
-        print("""Required for Root Patching non-Metal GPUs
+        print(
+            """Required for Root Patching non-Metal GPUs
 in macOS Big Sur. Without this, will receive kernel panic once
 Patcher finishes installing legacy acceleration patches.
-        """)
+        """
+        )
         change_menu = input("Disable AMFI(y/n): ")
         if change_menu in {"y", "Y", "yes", "Yes"}:
             self.constants.disable_amfi = True
@@ -211,25 +189,11 @@ Patcher finishes installing legacy acceleration patches.
         else:
             print("Invalid option")
 
-    def change_imac_nvidia(self):
-        Utilities.cls()
-        Utilities.header(["Assume Metal GPU Always"])
-        print("""Specifically for iMac10,x-12,x with Metal Nvidia GPU upgrades
-By default the patcher will try to detect what hardware is
-running, however this will enforce iMac Nvidia Build Patches.
-        """)
-        change_menu = input("Assume iMac Nvidia patches(y/n): ")
-        if change_menu in {"y", "Y", "yes", "Yes"}:
-            self.constants.imac_nvidia_build = True
-        elif change_menu in {"n", "N", "no", "No"}:
-            self.constants.imac_nvidia_build = False
-        else:
-            print("Invalid option")
-
     def bootstrap_setting(self):
         Utilities.cls()
         Utilities.header(["Set Bootstrap method"])
-        print("""Sets OpenCore's bootstrap method, currently the patcher supports the
+        print(
+            """Sets OpenCore's bootstrap method, currently the patcher supports the
 following options.
 
 Valid options:
@@ -244,7 +208,8 @@ and not to macOS itself.
 Recommended to set to BOOTx64.efi in situations where your Mac cannot
 see the EFI Boot entry in the boot picker.
 
-        """)
+        """
+        )
         change_menu = input("Set Bootstrap method: ")
         if change_menu == "1":
             self.constants.boot_efi = False
@@ -253,11 +218,11 @@ see the EFI Boot entry in the boot picker.
         else:
             print("Invalid option")
 
-
     def drm_setting(self):
         Utilities.cls()
         Utilities.header(["Set DRM preferences"])
-        print("""Sets OpenCore's DRM preferences for iMac13,x and iMac14,x.
+        print(
+            """Sets OpenCore's DRM preferences for iMac13,x and iMac14,x.
 In Big Sur, some DRM based content may be broken by
 default in AppleTV, Photobooth, etc.
 
@@ -267,7 +232,8 @@ greatly hampers Video rendering performance in Final Cut Pro and
 other programs relying on such features.
 
 Recommend only disabling if absolutely required.
-        """)
+        """
+        )
         change_menu = input("Enable Nvidia's Software DRM rendering(y/n): ")
         if change_menu in {"y", "Y", "yes", "Yes"}:
             self.constants.drm_support = True
@@ -276,30 +242,16 @@ Recommend only disabling if absolutely required.
         else:
             print("Invalid option")
 
-    def force_accel_setting(self):
-        Utilities.cls()
-        Utilities.header(["Assume Legacy GPU"])
-        print("""Allows any model to force install Legacy Acceleration
-patches. Only required for Mac Pro and Xserve users.
-
-DO NOT RUN IF METAL GPU IS INSTALLED
-        """)
-        change_menu = input("Enable Beta Acceleration Patches(y/n): ")
-        if change_menu in {"y", "Y", "yes", "Yes"}:
-            self.constants.assume_legacy = True
-        elif change_menu in {"n", "N", "no", "No"}:
-            self.constants.assume_legacy = False
-        else:
-            print("Invalid option")
-
     def allow_native_models(self):
         Utilities.cls()
         Utilities.header(["Allow OpenCore on native Models"])
-        print("""Allows natively supported Macs to use OpenCore. Recommended
+        print(
+            """Allows natively supported Macs to use OpenCore. Recommended
 for users with 3rd Party NVMe SSDs to achieve improved overall
 power usage.
 
-        """)
+        """
+        )
         change_menu = input("Allow OpenCore on all Models(y/n): ")
         if change_menu in {"y", "Y", "yes", "Yes"}:
             self.constants.allow_oc_everywhere = True
@@ -313,13 +265,15 @@ power usage.
     def custom_cpu(self):
         Utilities.cls()
         Utilities.header(["Set custom CPU Model Name"])
-        print("""Change reported CPU Model name in About This Mac
+        print(
+            """Change reported CPU Model name in About This Mac
 Custom names will report as follows:
 
 1: Original Name: 2.5 Ghz Dual-Core Intel Core i5
 2. CPU name:      Intel(R) Core(TM) i5-3210M CPU @ 2.50Ghz
 3. Custom Name:   2.5Ghz Cotton Candy (example)
-        """)
+        """
+        )
         if self.constants.custom_cpu_model_value == "":
             if self.constants.custom_cpu_model == 0:
                 print("Currently using original name")
@@ -343,12 +297,14 @@ Custom names will report as follows:
     def custom_color_thing(self):
         Utilities.cls()
         Utilities.header(["Set custom CPU Model Name"])
-        print("""Change reported CPU Model name in About This Mac
+        print(
+            """Change reported CPU Model name in About This Mac
 Custom names will report as follows:
 
 1: Custom Color
 2. Reset
-        """)
+        """
+        )
         change_menu = input("Set custom CPU Name(1,2,3): ")
         if change_menu == "1":
             print("")
@@ -361,28 +317,16 @@ Custom names will report as follows:
         else:
             print("Invalid option")
 
-    def download_more_ram_dot_com(self):
-        Utilities.cls()
-        Utilities.header(["Download more RAM"])
-        print("""Downloads more RAM to your Mac!
-Currently only offers 1.5TB bundles
-        """)
-        change_menu = input("Download more RAM?(y/n): ")
-        if change_menu == "y":
-            self.constants.download_ram = True
-        elif change_menu == "n":
-            self.constants.download_ram = False
-        else:
-            print("Invalid option")
-
     def disable_cpufriend(self):
         Utilities.cls()
         Utilities.header(["Disable CPU Friend?"])
-        print("""Only recommended for advanced users
+        print(
+            """Only recommended for advanced users
 Disabling CPUFriend forces macOS into using a different
 Mac's power profile for CPUs and GPUs, which can harm the
 hardware
-        """)
+        """
+        )
         change_menu = input("Disable CPU Friend?(y/n): ")
         if change_menu == "y":
             self.constants.disallow_cpufriend = True
@@ -394,24 +338,30 @@ hardware
     def set_seedutil(self):
         Utilities.cls()
         Utilities.header(["Set SeedUtil Status"])
-        print("""Used for setting OS Update Preferences
+        print(
+            """Used for setting OS Update Preferences
 
 Valid options:
 1. Public Release Seed (Default)
 2. Public Beta Seed
 3. Developer Beta Seed
 4. Check SeedUtil's current status
-        """)
+        """
+        )
 
         change_menu = input("Set update status(Press [ENTER] to exit): ")
         if change_menu == "1":
             subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         elif change_menu == "2":
             subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
-            subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "PublicSeed"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            subprocess.run(
+                ["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "PublicSeed"], stdout=subprocess.PIPE
+            ).stdout.decode().strip().encode()
         elif change_menu == "3":
             subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
-            subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "DeveloperSeed"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            subprocess.run(
+                ["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "enroll", "DeveloperSeed"], stdout=subprocess.PIPE
+            ).stdout.decode().strip().encode()
         elif change_menu == "4":
             result = subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "current"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
             result = [i.partition(":")[2] for i in result.stdout.decode().split("\n") if "Currently enrolled in" in i][0]
@@ -424,13 +374,15 @@ Valid options:
     def set_smbios(self):
         Utilities.cls()
         Utilities.header(["Override SMBIOS Spoof"])
-        print("""Change model OpenCore spoofs Mac too
+        print(
+            """Change model OpenCore spoofs Mac too
 
 Valid options:
 1. Default set by OpenCore (Default)
 2. User Override
 3. Disable all spoofing (unsupported configuration)
-        """)
+        """
+        )
 
         change_menu = input("Set SMBIOS status: ")
         if change_menu == "1":
@@ -453,7 +405,8 @@ Valid options:
     def allow_firewire(self):
         Utilities.cls()
         Utilities.header(["Allow FireWire Boot Support"])
-        print("""
+        print(
+            """
 In macOS Catalina and newer, Apple restricted
 usage of FireWire devices to boot macOS for
 security concerns relating to DMA access.
@@ -463,7 +416,8 @@ you can re-enable FireWire support for Catalina
 and newer.
 
 Note: MacBook5,x-7,1 don't support FireWire boot
-        """)
+        """
+        )
 
         change_menu = input("Enable FireWire Boot support?(y/n): ")
         if change_menu == "y":
@@ -476,7 +430,8 @@ Note: MacBook5,x-7,1 don't support FireWire boot
     def allow_nvme(self):
         Utilities.cls()
         Utilities.header(["Allow NVMe UEFI Support"])
-        print("""
+        print(
+            """
 For machines not natively supporting NVMe,
 this option allows you to see and boot NVMe
 drive in OpenCore's picker
@@ -486,7 +441,8 @@ Not required if your machine natively supports NVMe
 Note: You must have OpenCore on a bootable volume
 first, ie. USB or SATA drive. Once loaded,
 OpenCore will enable NVMe support in it's picker
-        """)
+        """
+        )
 
         change_menu = input("Enable NVMe Boot support?(y/n): ")
         if change_menu == "y":
@@ -496,11 +452,11 @@ OpenCore will enable NVMe support in it's picker
         else:
             print("Invalid option")
 
-
     def enable_terascale(self):
         Utilities.cls()
         Utilities.header(["Enable TeraScale 2 Acceleration"])
-        print("""
+        print(
+            """
 Currently TeraScale 2 graphics acceleration is in beta with
 some unfortunate bugs on login including strobing colours
 until the user forces Million Colours on the Display with
@@ -511,12 +467,13 @@ patches or ask someone to handle inital setup to ensure
 no issues
 
 Note: Acceleration only applies to macOS Big Sur
-        """)
+        """
+        )
 
         change_menu = input("Enable TS2 Acceleration?(y/n): ")
         if change_menu == "y":
-            self.constants.terscale_2_patch = True
+            self.constants.terascale_2_patch = True
         elif change_menu == "n":
-            self.constants.terscale_2_patch = False
+            self.constants.terascale_2_patch = False
         else:
             print("Invalid option")

Resources/Constants.py

@@ -5,11 +5,14 @@
 from __future__ import print_function
 
 from pathlib import Path
+from typing import Optional
+
+from Resources import device_probe
 
 
 class Constants:
     def __init__(self):
-        self.patcher_version = "0.1.7"
+        self.patcher_version = "0.2.2"
         self.opencore_commit = "4e0ff2d - 05-23-2021"
         self.opencore_version = "0.7.0"
         self.lilu_version = "1.5.4"
@@ -34,23 +37,22 @@ class Constants:
         self.cpufriend_version = "1.2.4"
         self.nightshift_version = "1.1.0"
         self.smcspoof_version = "1.0.0"
-        self.cputscsync = "1.0.3"
-        self.hibernationfixup = "1.3.9"
         self.nvmefix_version = "1.0.9"
         self.sidecarfixup_version = "1.0.2"
         self.debugenhancer_version = "1.0.3"
         self.innie_version = "1.3.0"
         self.fw_kext = "1.0.0"
-        self.payload_version = "0.0.18" # Apple-Binaries-OCLP
+        self.patcher_support_pkg_version = "0.0.10"  # PatcherSupportPkg
 
         # Get resource path
         self.current_path = Path(__file__).parent.parent.resolve()
         self.payload_path = self.current_path / Path("payloads")
 
-        self.custom_model: str = None
+        # Hardware
-        self.custom_mxm_gpu: str = None
+        self.computer: device_probe.Computer = None  # type: ignore
-        self.current_gpuv: str = None
+
-        self.current_gpud: str = None
+        self.custom_model: Optional[str] = None
+        self.custom_mxm_gpu: bool = False
 
         # Patcher Settings
         self.opencore_debug = False
@@ -58,8 +60,6 @@ class Constants:
         self.kext_debug = False
         self.verbose_debug = False
         self.os_support = 12.0
-        self.min_os_support = 11.0
-        self.max_os_support = 12.0
         self.metal_build = False
         self.imac_vendor = "None"
         self.wifi_build = False
@@ -72,8 +72,6 @@ class Constants:
         self.detected_os = 0
         self.boot_efi = False
         self.drm_support = False
-        self.legacy_acceleration_patch = True
-        self.assume_legacy = False
         self.allow_oc_everywhere = False
         self.custom_cpu_model = 2
         self.custom_cpu_model_value = ""
@@ -86,7 +84,7 @@ class Constants:
         self.firewire_boot = False
         self.nvme_boot = False
         self.disable_amfi = False
-        self.terscale_2_patch = False
+        self.terascale_2_patch = False
 
         # OS Versions
         self.tiger = 8
@@ -128,243 +126,389 @@ class Constants:
         self.arch_kepler = "GK100"
 
         # External Files
-        self.url_apple_binaries = "https://github.com/dortania/Apple-Binaries-OCLP/archive/refs/tags/"
+        self.url_patcher_support_pkg = "https://github.com/dortania/PatcherSupportPkg/releases/download/"
 
     # Payload Location
     # OpenCore
     @property
-    def opencore_zip_source(self): return self.payload_path / Path(f"OpenCore/OpenCore-{self.opencore_build}.zip")
+    def opencore_zip_source(self):
+        return self.payload_path / Path(f"OpenCore/OpenCore-{self.opencore_build}.zip")
+
     @property
-    def plist_template(self): return self.payload_path / Path(f"Config/config.plist")
+    def plist_template(self):
+        return self.payload_path / Path("Config/config.plist")
 
     # Mount Location
     @property
-    def payload_mnt1_path(self): return self.payload_path / Path("mnt1")
+    def payload_mnt1_path(self):
+        return self.payload_path / Path("mnt1")
 
     # ACPI
     @property
-    def pci_ssdt_path(self): return self.payload_path / Path("ACPI/SSDT-CPBG.aml")
+    def pci_ssdt_path(self):
+        return self.payload_path / Path("ACPI/SSDT-CPBG.aml")
+
     @property
-    def windows_ssdt_path(self): return self.payload_path / Path("ACPI/SSDT-PCI.aml")
+    def windows_ssdt_path(self):
+        return self.payload_path / Path("ACPI/SSDT-PCI.aml")
 
     # Drivers
     @property
-    def nvme_driver_path(self): return self.payload_path / Path("Drivers/NvmExpressDxe.efi")
+    def nvme_driver_path(self):
+        return self.payload_path / Path("Drivers/NvmExpressDxe.efi")
+
     @property
-    def exfat_legacy_driver_path(self): return self.payload_path / Path("Drivers/ExFatDxeLegacy.efi")
+    def exfat_legacy_driver_path(self):
+        return self.payload_path / Path("Drivers/ExFatDxeLegacy.efi")
+
     @property
-    def xhci_driver_path(self): return self.payload_path / Path("Drivers/XhciDxe.efi")
+    def xhci_driver_path(self):
+        return self.payload_path / Path("Drivers/XhciDxe.efi")
 
     # Kexts
     @property
-    def payload_kexts_path(self): return self.payload_path / Path("Kexts")
+    def payload_kexts_path(self):
+        return self.payload_path / Path("Kexts")
+
     @property
-    def lilu_path(self): return self.payload_kexts_path / Path(f"Acidanthera/Lilu-v{self.lilu_version}.zip")
+    def lilu_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/Lilu-v{self.lilu_version}.zip")
+
     @property
-    def whatevergreen_path(self): return self.payload_kexts_path / Path(f"Acidanthera/WhateverGreen-v{self.whatevergreen_version}.zip")
+    def whatevergreen_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/WhateverGreen-v{self.whatevergreen_version}.zip")
+
     @property
-    def airportbcrmfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/AirportBrcmFixup-v{self.airportbcrmfixup_version}.zip")
+    def airportbcrmfixup_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/AirportBrcmFixup-v{self.airportbcrmfixup_version}.zip")
+
     @property
-    def restrictevents_path(self): return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-v{self.restrictevents_version}.zip")
+    def restrictevents_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-v{self.restrictevents_version}.zip")
+
     @property
-    def restrictevents_mbp_path(self): return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-MBP91-v{self.restrictevents_mbp_version}.zip")
+    def restrictevents_mbp_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/RestrictEvents-MBP91-v{self.restrictevents_mbp_version}.zip")
+
     @property
-    def bcm570_path(self): return self.payload_kexts_path / Path(f"Ethernet/CatalinaBCM5701Ethernet-v{self.bcm570_version}.zip")
+    def bcm570_path(self):
+        return self.payload_kexts_path / Path(f"Ethernet/CatalinaBCM5701Ethernet-v{self.bcm570_version}.zip")
+
     @property
-    def marvel_path(self): return self.payload_kexts_path / Path(f"Ethernet/MarvelYukonEthernet-v{self.marvel_version}.zip")
+    def marvel_path(self):
+        return self.payload_kexts_path / Path(f"Ethernet/MarvelYukonEthernet-v{self.marvel_version}.zip")
+
     @property
-    def nforce_path(self): return self.payload_kexts_path / Path(f"Ethernet/nForceEthernet-v{self.nforce_version}.zip")
+    def nforce_path(self):
+        return self.payload_kexts_path / Path(f"Ethernet/nForceEthernet-v{self.nforce_version}.zip")
+
     @property
-    def mce_path(self): return self.payload_kexts_path / Path(f"Misc/AppleMCEReporterDisabler-v{self.mce_version}.zip")
+    def mce_path(self):
+        return self.payload_kexts_path / Path(f"Misc/AppleMCEReporterDisabler-v{self.mce_version}.zip")
+
     @property
-    def mousse_path(self): return self.payload_kexts_path / Path(f"SSE/AAAMouSSE-v{self.mousse_version}.zip")
+    def mousse_path(self):
+        return self.payload_kexts_path / Path(f"SSE/AAAMouSSE-v{self.mousse_version}.zip")
+
     @property
-    def telemetrap_path(self): return self.payload_kexts_path / Path(f"SSE/telemetrap-v{self.telemetrap_version}.zip")
+    def telemetrap_path(self):
+        return self.payload_kexts_path / Path(f"SSE/telemetrap-v{self.telemetrap_version}.zip")
+
     @property
-    def corecaptureelcap_path(self): return self.payload_kexts_path / Path(f"Wifi/corecaptureElCap-v{self.corecaptureelcap_version}.zip")
+    def corecaptureelcap_path(self):
+        return self.payload_kexts_path / Path(f"Wifi/corecaptureElCap-v{self.corecaptureelcap_version}.zip")
+
     @property
-    def io80211elcap_path(self): return self.payload_kexts_path / Path(f"Wifi/IO80211ElCap-v{self.io80211elcap_version}.zip")
+    def io80211elcap_path(self):
+        return self.payload_kexts_path / Path(f"Wifi/IO80211ElCap-v{self.io80211elcap_version}.zip")
+
     @property
-    def io80211high_sierra_path(self): return self.payload_kexts_path / Path(f"Wifi/IO80211HighSierra-v{self.io80211high_sierra_version}.zip")
+    def io80211high_sierra_path(self):
+        return self.payload_kexts_path / Path(f"Wifi/IO80211HighSierra-v{self.io80211high_sierra_version}.zip")
+
     @property
-    def io80211mojave_path(self): return self.payload_kexts_path / Path(f"Wifi/IO80211Mojave-v{self.io80211mojave_version}.zip")
+    def io80211mojave_path(self):
+        return self.payload_kexts_path / Path(f"Wifi/IO80211Mojave-v{self.io80211mojave_version}.zip")
+
     @property
-    def applealc_path(self): return self.payload_kexts_path / Path(f"Acidanthera/AppleALC-v{self.applealc_version}.zip")
+    def applealc_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/AppleALC-v{self.applealc_version}.zip")
+
     @property
-    def piixata_path(self): return self.payload_kexts_path / Path(f"Misc/AppleIntelPIIXATA-v{self.piixata_version}.zip")
+    def piixata_path(self):
+        return self.payload_kexts_path / Path(f"Misc/AppleIntelPIIXATA-v{self.piixata_version}.zip")
+
     @property
-    def backlight_path(self): return self.payload_kexts_path / Path(f"Misc/AppleBacklightFixup-v{self.backlight_version}.zip")
+    def backlight_path(self):
+        return self.payload_kexts_path / Path(f"Misc/AppleBacklightFixup-v{self.backlight_version}.zip")
+
     @property
-    def backlight_injector_path(self): return self.payload_kexts_path / Path(f"Misc/BacklightInjector-v{self.backlight_injector_version}.zip")
+    def backlight_injector_path(self):
+        return self.payload_kexts_path / Path(f"Misc/BacklightInjector-v{self.backlight_injector_version}.zip")
+
     @property
-    def cpufriend_path(self): return self.payload_kexts_path / Path(f"Acidanthera/CPUFriend-v{self.cpufriend_version}.zip")
+    def cpufriend_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/CPUFriend-v{self.cpufriend_version}.zip")
+
     @property
-    def nightshift_path(self): return self.payload_kexts_path / Path(f"Misc/NightShiftEnabler-v{self.nightshift_version}.zip")
+    def nightshift_path(self):
+        return self.payload_kexts_path / Path(f"Misc/NightShiftEnabler-v{self.nightshift_version}.zip")
+
     @property
-    def smcspoof_path(self): return self.payload_kexts_path / Path(f"Misc/SMC-Spoof-v{self.smcspoof_version}.zip")
+    def smcspoof_path(self):
+        return self.payload_kexts_path / Path(f"Misc/SMC-Spoof-v{self.smcspoof_version}.zip")
+
     @property
-    def cputscsync_path(self): return self.payload_kexts_path / Path(f"Acidanthera/CpuTscSync-v{self.cputscsync}.zip")
+    def nvmefix_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/NVMeFix-v{self.nvmefix_version}.zip")
+
     @property
-    def hibernationfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/HibernationFixup-v{self.hibernationfixup}.zip")
+    def sidecarfixup_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/SidecarFixup-v{self.sidecarfixup_version}.zip")
+
     @property
-    def nvmefix_path(self): return self.payload_kexts_path / Path(f"Acidanthera/NVMeFix-v{self.nvmefix_version}.zip")
+    def debugenhancer_path(self):
+        return self.payload_kexts_path / Path(f"Acidanthera/DebugEnhancer-v{self.debugenhancer_version}.zip")
+
     @property
-    def sidecarfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/SidecarFixup-v{self.sidecarfixup_version}.zip")
+    def innie_path(self):
+        return self.payload_kexts_path / Path(f"Misc/Innie-v{self.innie_version}.zip")
+
     @property
-    def debugenhancer_path(self): return self.payload_kexts_path / Path(f"Acidanthera/DebugEnhancer-v{self.debugenhancer_version}.zip")
+    def plist_folder_path(self):
+        return self.payload_kexts_path / Path("Plists")
+
     @property
-    def innie_path(self): return self.payload_kexts_path / Path(f"Misc/Innie-v{self.innie_version}.zip")
+    def platform_plugin_plist_path(self):
+        return self.plist_folder_path / Path("PlatformPlugin")
+
     @property
-    def plist_folder_path(self): return self.payload_kexts_path / Path(f"Plists")
+    def fw_family_path(self):
+        return self.payload_kexts_path / Path(f"FireWire/IOFireWireFamily-v{self.fw_kext}.zip")
+
     @property
-    def platform_plugin_plist_path(self): return self.plist_folder_path / Path(f"PlatformPlugin")
+    def fw_sbp2_path(self):
+        return self.payload_kexts_path / Path(f"FireWire/IOFireWireSBP2-v{self.fw_kext}.zip")
+
     @property
-    def fw_family_path(self): return self.payload_kexts_path / Path(f"FireWire/IOFireWireFamily-v{self.fw_kext}.zip")
+    def fw_bus_path(self):
-    @property
+        return self.payload_kexts_path / Path(f"FireWire/IOFireWireSerialBusProtocolTransport-v{self.fw_kext}.zip")
-    def fw_sbp2_path(self): return self.payload_kexts_path / Path(f"FireWire/IOFireWireSBP2-v{self.fw_kext}.zip")
-    @property
-    def fw_bus_path(self): return self.payload_kexts_path / Path(f"FireWire/IOFireWireSerialBusProtocolTransport-v{self.fw_kext}.zip")
 
     # Build Location
     @property
-    def build_path(self): return self.current_path / Path("Build-Folder/")
+    def build_path(self):
-    @property
+        return self.current_path / Path("Build-Folder/")
-    def opencore_release_folder(self): return self.build_path / Path(f"OpenCore-{self.opencore_build}")
-    @property
-    def opencore_zip_copied(self): return self.build_path / Path(f"OpenCore-{self.opencore_build}.zip")
 
     @property
-    def oc_folder(self): return self.opencore_release_folder / Path("EFI/OC/")
+    def opencore_release_folder(self):
+        return self.build_path / Path(f"OpenCore-{self.opencore_build}")
+
     @property
-    def plist_path(self): return self.oc_folder / Path("config.plist")
+    def opencore_zip_copied(self):
+        return self.build_path / Path(f"OpenCore-{self.opencore_build}.zip")
+
     @property
-    def acpi_path(self): return self.oc_folder / Path("ACPI")
+    def oc_folder(self):
+        return self.opencore_release_folder / Path("EFI/OC/")
+
     @property
-    def drivers_path(self): return self.oc_folder / Path("Drivers")
+    def plist_path(self):
+        return self.oc_folder / Path("config.plist")
+
     @property
-    def kexts_path(self): return self.oc_folder / Path("Kexts")
+    def acpi_path(self):
+        return self.oc_folder / Path("ACPI")
+
     @property
-    def resources_path(self): return self.oc_folder / Path("Resources")
+    def drivers_path(self):
+        return self.oc_folder / Path("Drivers")
+
     @property
-    def map_kext_folder(self): return self.kexts_path / Path("USB-Map.kext")
+    def kexts_path(self):
+        return self.oc_folder / Path("Kexts")
+
     @property
-    def map_contents_folder(self): return self.map_kext_folder / Path("Contents")
+    def resources_path(self):
+        return self.oc_folder / Path("Resources")
+
     @property
-    def pp_kext_folder(self): return self.kexts_path / Path("CPUFriendDataProvider.kext")
+    def map_kext_folder(self):
+        return self.kexts_path / Path("USB-Map.kext")
+
     @property
-    def pp_contents_folder(self): return self.pp_kext_folder / Path("Contents")
+    def map_contents_folder(self):
+        return self.map_kext_folder / Path("Contents")
+
     @property
-    def agdp_kext_folder(self): return self.kexts_path / Path("AGDP-Override.kext")
+    def pp_kext_folder(self):
+        return self.kexts_path / Path("CPUFriendDataProvider.kext")
+
     @property
-    def agdp_contents_folder(self): return self.agdp_kext_folder / Path("Contents")
+    def pp_contents_folder(self):
+        return self.pp_kext_folder / Path("Contents")
+
     @property
-    def agpm_kext_folder(self): return self.kexts_path / Path("AGPM-Override.kext")
+    def agdp_kext_folder(self):
+        return self.kexts_path / Path("AGDP-Override.kext")
+
     @property
-    def agpm_contents_folder(self): return self.agpm_kext_folder / Path("Contents")
+    def agdp_contents_folder(self):
+        return self.agdp_kext_folder / Path("Contents")
+
     @property
-    def amc_kext_folder(self): return self.kexts_path / Path("AMC-Override.kext")
+    def agpm_kext_folder(self):
+        return self.kexts_path / Path("AGPM-Override.kext")
+
     @property
-    def amc_contents_folder(self): return self.amc_kext_folder / Path("Contents")
+    def agpm_contents_folder(self):
+        return self.agpm_kext_folder / Path("Contents")
+
+    @property
+    def amc_kext_folder(self):
+        return self.kexts_path / Path("AMC-Override.kext")
+
+    @property
+    def amc_contents_folder(self):
+        return self.amc_kext_folder / Path("Contents")
 
     # Tools
     @property
-    def macserial_path(self): return self.payload_path / Path("Tools/macserial")
+    def macserial_path(self):
+        return self.payload_path / Path("Tools/macserial")
+
     @property
-    def gfxutil_path(self): return self.payload_path / Path("Tools/gfxutil")
+    def gfxutil_path(self):
+        return self.payload_path / Path("Tools/gfxutil")
+
     @property
-    def vault_path(self): return self.payload_path / Path("Tools/CreateVault/sign.command")
+    def vault_path(self):
+        return self.payload_path / Path("Tools/CreateVault/sign.command")
 
     # Icons
     @property
-    def app_icon_path(self): return self.current_path / Path("OC-Patcher.icns")
+    def app_icon_path(self):
+        return self.current_path / Path("OC-Patcher.icns")
+
     @property
-    def icon_path_external(self): return self.payload_path / Path("Icon/External/.VolumeIcon.icns")
+    def icon_path_external(self):
+        return self.payload_path / Path("Icon/External/.VolumeIcon.icns")
+
     @property
-    def icon_path_internal(self): return self.payload_path / Path("Icon/Internal/.VolumeIcon.icns")
+    def icon_path_internal(self):
+        return self.payload_path / Path("Icon/Internal/.VolumeIcon.icns")
+
     @property
-    def icon_path_sd(self): return self.payload_path / Path("Icon/SD-Card/.VolumeIcon.icns")
+    def icon_path_sd(self):
+        return self.payload_path / Path("Icon/SD-Card/.VolumeIcon.icns")
+
     @property
-    def icon_path_ssd(self): return self.payload_path / Path("Icon/SSD/.VolumeIcon.icns")
+    def icon_path_ssd(self):
+        return self.payload_path / Path("Icon/SSD/.VolumeIcon.icns")
+
     @property
-    def gui_path(self): return self.payload_path / Path("Icon/Resources.zip")
+    def gui_path(self):
+        return self.payload_path / Path("Icon/Resources.zip")
 
     # Apple Payloads Paths
+
     @property
-    def payload_apple_root_path_unzip(self): return self.payload_path / Path(f"Apple-Binaries-OCLP-{self.payload_version}")
+    def payload_apple_root_path_zip(self):
+        return self.payload_path / Path("Apple.zip")
+
     @property
-    def payload_apple_root_path_zip(self): return self.payload_path / Path("Apple.zip")
+    def payload_apple_root_path(self):
+        return self.payload_path / Path("Apple")
+
     @property
-    def payload_apple_root_path(self): return self.payload_path / Path("Apple")
+    def payload_apple_kexts_path(self):
+        return self.payload_apple_root_path / Path("Extensions")
+
     @property
-    def payload_apple_kexts_path(self): return self.payload_apple_root_path / Path("Extensions")
+    def payload_apple_frameworks_path(self):
+        return self.payload_apple_root_path / Path("Frameworks")
+
     @property
-    def payload_apple_frameworks_path(self): return self.payload_apple_root_path / Path("Frameworks")
+    def payload_apple_frameworks_path_accel(self):
+        return self.payload_apple_frameworks_path / Path("Graphics-Acceleration")
+
     @property
-    def payload_apple_frameworks_path_accel(self): return self.payload_apple_frameworks_path / Path("Graphics-Acceleration")
+    def payload_apple_frameworks_path_accel_ts2(self):
+        return self.payload_apple_frameworks_path / Path("Graphics-Acceleration-TeraScale-2")
+
     @property
-    def payload_apple_frameworks_path_accel_ts2(self): return self.payload_apple_frameworks_path / Path("Graphics-Acceleration-TS2")
+    def payload_apple_frameworks_path_accel_ivy(self):
+        return self.payload_apple_frameworks_path / Path("Graphics-Acceleration-Ivy-Bridge")
+
     @property
-    def payload_apple_lauchd_path(self): return self.payload_apple_root_path / Path("LaunchDaemons")
+    def payload_apple_lauchd_path(self):
+        return self.payload_apple_root_path / Path("LaunchDaemons")
+
     @property
-    def payload_apple_lauchd_path_accel(self): return self.payload_apple_lauchd_path / Path("Graphics-Acceleration")
+    def payload_apple_lauchd_path_accel(self):
+        return self.payload_apple_lauchd_path / Path("Graphics-Acceleration")
+
     @property
-    def payload_apple_private_frameworks_path(self): return self.payload_apple_root_path / Path("PrivateFrameworks")
+    def payload_apple_private_frameworks_path(self):
+        return self.payload_apple_root_path / Path("PrivateFrameworks")
+
     @property
-    def payload_apple_private_frameworks_path_accel(self): return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration")
+    def payload_apple_private_frameworks_path_accel(self):
+        return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration")
+
     @property
-    def payload_apple_private_frameworks_path_accel_ts2(self): return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration-TS2")
+    def payload_apple_private_frameworks_path_accel_ts2(self):
+        return self.payload_apple_private_frameworks_path / Path("Graphics-Acceleration-TeraScale-2")
+
     @property
-    def payload_apple_private_frameworks_path_brightness(self): return self.payload_apple_private_frameworks_path / Path("Brightness-Control")
+    def payload_apple_private_frameworks_path_brightness(self):
+        return self.payload_apple_private_frameworks_path / Path("Brightness-Control")
 
     # Apple Extensions
     @property
-    def audio_path(self): return self.payload_apple_kexts_path / Path("Audio")
+    def audio_path(self):
+        return self.payload_apple_kexts_path / Path("Audio")
 
     # GPU Kexts and Bundles
 
     @property
-    def legacy_graphics(self): return self.payload_apple_kexts_path / Path("Graphics-Acceleration")
+    def legacy_graphics(self):
-    @property
+        return self.payload_apple_kexts_path / Path("Graphics-Acceleration")
-    def legacy_graphics_ts2(self): return self.payload_apple_kexts_path / Path("Graphics-Acceleration-TS2")
-    @property
-    def legacy_nvidia_path(self): return self.legacy_graphics / Path("Nvidia-Tesla-Fermi")
-    @property
-    def legacy_nvidia_kepler_path(self): return self.legacy_graphics / Path("Nvidia-Kepler")
-    @property
-    def legacy_amd_path(self): return self.legacy_graphics / Path("AMD-ATI")
-    @property
-    def legacy_amd_path_ts2(self): return self.legacy_graphics / Path("ATI-TS2")
-    @property
-    def legacy_intel_gen1_path(self): return self.legacy_graphics / Path("Intel-Gen5-Ironlake")
-    @property
-    def legacy_intel_gen2_path(self): return self.legacy_graphics / Path("Intel-Gen6-SandyBridge")
-    @property
-    def legacy_intel_gen3_path(self): return self.legacy_graphics / Path("Intel-Gen7-IvyBridge")
-    @property
-    def legacy_general_path(self): return self.legacy_graphics / Path("General-Patches")
 
     @property
-    def legacy_brightness(self): return self.payload_apple_kexts_path / Path("Brightness-Control")
+    def legacy_nvidia_path(self):
+        return self.legacy_graphics / Path("Nvidia-Tesla")
 
-    # Apple Frameworks
     @property
-    def coredisplay_path(self): return self.payload_apple_frameworks_path_accel / Path("CoreDisplay.framework")
+    def legacy_nvidia_kepler_path(self):
-    @property
+        return self.legacy_graphics / Path("Nvidia-Kepler")
-    def iosurface_f_path(self): return self.payload_apple_frameworks_path_accel / Path("IOSurface.framework")
-    @property
-    def opengl_path(self): return self.payload_apple_frameworks_path_accel / Path("OpenGL.framework")
 
-    # Apple LaunchDaemons
     @property
-    def hiddhack_path(self): return self.payload_apple_lauchd_path_accel / Path("IOHID-Fixup.plist")
+    def legacy_amd_path(self):
-    @property
+        return self.legacy_graphics / Path("AMD-TeraScale")
-    def legacy_hiddhack_path(self): return self.payload_apple_lauchd_path_accel / Path("HiddHack.plist")
 
-    # Apple PrivateFrameworks
     @property
-    def gpusupport_path(self): return self.payload_apple_private_frameworks_path_accel / Path("GPUSupport.framework")
+    def legacy_amd_path_ts2(self):
+        return self.legacy_graphics / Path("AMD-TeraScale-2")
+
     @property
-    def skylight_path(self): return self.payload_apple_private_frameworks_path_accel / Path("SkyLight.framework")
+    def legacy_intel_gen1_path(self):
+        return self.legacy_graphics / Path("Intel-Gen5-Ironlake")
+
+    @property
+    def legacy_intel_gen2_path(self):
+        return self.legacy_graphics / Path("Intel-Gen6-SandyBridge")
+
+    @property
+    def legacy_intel_gen3_path(self):
+        return self.legacy_graphics / Path("Intel-Gen7-IvyBridge")
+
+    @property
+    def legacy_general_path(self):
+        return self.legacy_graphics / Path("General-Patches")
+
+    @property
+    def legacy_brightness(self):
+        return self.payload_apple_kexts_path / Path("Brightness-Control")
 
     csr_values = {
         "CSR_ALLOW_UNTRUSTED_KEXTS": False,  # 0x1   - Allows Unsigned Kexts           - Introduced in El Capitan  # noqa: E241
@@ -442,7 +586,7 @@ class Constants:
         "MacBookAir7,1": "Mac-9F18E312C5C2BF0B",
         "MacBookAir7,2": "Mac-937CB26E2E02BB01",
         "MacBookAir8,1": "Mac-827FAC58A8FDFA22",
-        "MacBookAir8,1": "Mac-226CB3C6A851A671",
+        "MacBookAir8,2": "Mac-226CB3C6A851A671",
         "MacBookAir9,1": "Mac-0CFF9C7C2B63DF8D",
         "MacBookPro1,1": "Mac-F425BEC8",
         "MacBookPro1,2": "Mac-F42DBEC8",
@@ -505,14 +649,13 @@ class Constants:
         "iMac8,1": "Mac-F227BEC8",
         "iMac9,1": "Mac-F2218FA9",
         "iMac10,1": "Mac-F221DCC8",
-        "iMac10,1": "Mac-F2268CC8",
+        # "iMac10,1": "Mac-F2268CC8",
         "iMac11,1": "Mac-F2268DAE",
         "iMac11,2": "Mac-F2238AC8",
         "iMac11,3": "Mac-F2238BAE",
         "iMac12,1": "Mac-942B5BF58194151B",
         "iMac12,2": "Mac-942B59F58194171B",
         "iMac13,1": "Mac-00BE6ED71E35EB86",
-        "iMac13,1": "Mac-00BE6ED71E35EB86",
         "iMac13,2": "Mac-FC02E91DDD3FA6A4",
         "iMac13,3": "Mac-7DF2A3B5E5D671ED",
         "iMac14,1": "Mac-031B6874CF7F642A",

Resources/DeviceProbe.py

@@ -1,116 +0,0 @@
-# Probe devices, return device entries
-# Copyright (C) 2021 Mykola Grymalyuk
-from __future__ import print_function
-
-import binascii
-import plistlib
-import subprocess
-
-from Resources import Constants, Utilities
-
-class pci_probe:
-    def __init__(self):
-        self.constants = Constants.Constants()
-
-    # Converts given device IDs to DeviceProperty pathing, requires ACPI pathing as DeviceProperties shouldn't be used otherwise
-    def deviceproperty_probe(self, vendor_id, device_id, acpi_path):
-        gfxutil_output: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-        try:
-            if acpi_path == "":
-                acpi_path = "No ACPI Path Given"
-                raise IndexError
-            device_path = [line.strip().split("= ", 1)[1] for line in gfxutil_output.split("\n") if f'{vendor_id}:{device_id}'.lower() in line.strip() and acpi_path in line.strip()][0]
-            return device_path
-        except IndexError:
-            print(f"- No DevicePath found for {vendor_id}:{device_id} ({acpi_path})")
-            return ""
-
-    # Returns the device path of parent controller
-    def device_property_parent(self, device_path):
-        device_path_parent = "/".join(device_path.split("/")[:-1])
-        return device_path_parent
-
-    def acpi_strip(self, acpi_path_full):
-        # Strip IOACPIPlane:/_SB, remove 000's, convert ffff into 0 and finally make everything upper case
-        # IOReg                                      | gfxutil
-        # IOACPIPlane:/_SB/PC00@0/DMI0@0             -> /PC00@0/DMI0@0
-        # IOACPIPlane:/_SB/PC03@0/BR3A@0/SL09@ffff   -> /PC03@0/BR3A@0/SL09@0
-        # IOACPIPlane:/_SB/PC03@0/M2U0@150000        -> /PC03@0/M2U0@15
-        # IOACPIPlane:/_SB/PC01@0/CHA6@100000        -> /PC01@0/CHA6@10
-        # IOACPIPlane:/_SB/PC00@0/RP09@1d0000/PXSX@0 -> /PC00@0/RP09@1D/PXSX@0
-        # IOACPIPlane:/_SB/PCI0@0/P0P2@10000         -> /PCI0@0/P0P2@1
-        acpi_path = acpi_path_full.replace("IOACPIPlane:/_SB", "")
-        acpi_path = acpi_path.replace("0000", "")
-        for entry in ["1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"]:
-            acpi_path = acpi_path.replace(f"000{entry}", f",{entry}")
-        acpi_path = acpi_path.replace("ffff", "0")
-        acpi_path = acpi_path.upper()
-        return acpi_path
-
-    # Note gpu_probe should only be used on IGPU and GFX0 entries
-    def gpu_probe(self, gpu_type):
-        try:
-            devices = plistlib.loads(subprocess.run(f"ioreg -r -n {gpu_type} -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            vendor_id = Utilities.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
-            device_id = Utilities.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
-            try:
-                acpi_path = devices[0]["acpi-path"]
-                acpi_path = self.acpi_strip(acpi_path)
-                return vendor_id, device_id, acpi_path
-            except KeyError:
-                print(f"- No ACPI entry found for {gpu_type}")
-                return vendor_id, device_id, ""
-        except ValueError:
-            print(f"- No IOService entry found for {gpu_type} (V)")
-            return "", "", ""
-        except IndexError:
-            print(f"- No IOService entry found for {gpu_type} (I)")
-            return "", "", ""
-
-    def wifi_probe(self):
-        devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-        try:
-            devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_wifi)]
-            vendor_id = Utilities.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
-            device_id = Utilities.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
-            ioname = devices[0]["IOName"]
-            try:
-                acpi_path = devices[0]["acpi-path"]
-                acpi_path = self.acpi_strip(acpi_path)
-                return vendor_id, device_id, ioname, acpi_path
-            except KeyError:
-                print(f"- No ACPI entry found for {vendor_id}:{device_id}")
-                return vendor_id, device_id, ioname, ""
-        except ValueError:
-            print(f"- No IOService entry found for Wireless Card (V)")
-            return "", "", "", ""
-        except IndexError:
-            print(f"- No IOService entry found for Wireless Card (I)")
-            return "", "", "", ""
-
-    def cpu_feature(self, instruction):
-        cpu_features = subprocess.run("sysctl machdep.cpu.features".split(), stdout=subprocess.PIPE).stdout.decode().partition(": ")[2].strip().split(" ")
-        if instruction in cpu_features:
-            print(f"- Found {instruction} support")
-            return True
-        else:
-            print(f"- Failed to find {instruction} support")
-            return False
-
-class smbios_probe:
-    def model_detect(self, custom):
-        opencore_model: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:oem-product".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-        if not opencore_model.startswith("nvram: Error getting variable") and custom is False:
-            current_model = [line.strip().split(":oem-product	", 1)[1] for line in opencore_model.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
-        else:
-            current_model = plistlib.loads(subprocess.run("system_profiler -detailLevel mini -xml SPHardwareDataType".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.strip())[0]["_items"][0]["machine_model"]
-        return current_model
-
-    def board_detect(self, custom):
-        opencore_model: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:oem-board".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-        if not opencore_model.startswith("nvram: Error getting variable") and custom is False:
-            current_model = [line.strip().split(":oem-board	", 1)[1] for line in opencore_model.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
-        else:
-            current_model = plistlib.loads(subprocess.run(f"ioreg -p IODeviceTree -r -n / -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            current_model = current_model[0]["board-id"]
-        return current_model

Resources/ModelArray.py

@@ -1,76 +1,6 @@
 # Lists all models and required patches
 # Copyright (C) 2020-2021, Dhinak G, Mykola Grymalyuk
 SupportedSMBIOS = [
-    # To be overwritten on program start
-]
-
-SupportedSMBIOS11 = [
-    # MacBook
-    "MacBook4,1",
-    "MacBook5,1",
-    "MacBook5,2",
-    "MacBook6,1",
-    "MacBook7,1",
-    # MacBook Air
-    "MacBookAir2,1",
-    "MacBookAir3,1",
-    "MacBookAir3,2",
-    "MacBookAir4,1",
-    "MacBookAir4,2",
-    "MacBookAir5,1",
-    "MacBookAir5,2",
-    # MacBook Pro
-    "MacBookPro4,1",
-    "MacBookPro5,1",
-    "MacBookPro5,2",
-    "MacBookPro5,3",
-    "MacBookPro5,4",
-    "MacBookPro5,5",
-    "MacBookPro6,1",
-    "MacBookPro6,2",
-    "MacBookPro7,1",
-    "MacBookPro8,1",
-    "MacBookPro8,2",
-    "MacBookPro8,3",
-    "MacBookPro9,1",
-    "MacBookPro9,2",
-    "MacBookPro10,1",
-    "MacBookPro10,2",
-    # Mac Mini
-    "Macmini3,1",
-    "Macmini4,1",
-    "Macmini5,1",
-    "Macmini5,2",
-    "Macmini5,3",
-    "Macmini6,1",
-    "Macmini6,2",
-    # iMac
-    "iMac7,1",
-    "iMac8,1",
-    "iMac9,1",
-    "iMac10,1",
-    "iMac11,1",
-    "iMac11,2",
-    "iMac11,3",
-    "iMac12,1",
-    "iMac12,2",
-    "iMac13,1",
-    "iMac13,2",
-    "iMac13,3",
-    "iMac14,1",
-    "iMac14,2",
-    "iMac14,3",
-    # Mac Pro
-    "MacPro3,1",
-    "MacPro4,1",
-    "MacPro5,1",
-    # Xserve
-    "Xserve2,1",
-    "Xserve3,1",
-    "Dortania1,1",
-]
-
-SupportedSMBIOS12 = [
     # MacBook
     "MacBook4,1",
     "MacBook5,1",
@@ -170,32 +100,14 @@ MissingSSE42 = [
     "iMac10,1",
     "MacPro3,1",
     "Xserve2,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
-SSEEmulator = [
+SSEEmulator = ["MacPro3,1", "Xserve2,1", "Dortania1,1"]
-    "MacPro3,1",
-    "Xserve2,1",
-    "Dortania1,1"
-]
 
-DualSocket = [
+DualSocket = ["MacPro3,1", "MacPro4,1", "MacPro5,1", "Xserve2,1", "Xserve3,1", "Dortania1,1"]
-    "MacPro3,1",
-    "MacPro4,1",
-    "MacPro5,1",
-    "Xserve2,1",
-    "Xserve3,1",
-    "Dortania1,1"
-]
 
-pciSSDT = [
+pciSSDT = ["MacBookPro6,1", "MacBookPro6,2", "iMac11,1", "iMac11,2", "iMac11,3", "Dortania1,1"]
-    "MacBookPro6,1",
-    "MacBookPro6,2",
-    "iMac11,1",
-    "iMac11,2",
-    "iMac11,3",
-    "Dortania1,1"
-]
 
 # Ethernet patches
 
@@ -212,15 +124,9 @@ EthernetNvidia = [
     "Macmini3,1",
     "iMac9,1",
     "iMac10,1",
-    "Dortania1,1"
+    "Dortania1,1",
-]
-EthernetMarvell = [
-    "MacBook4,1",
-    "MacBookPro4,1",
-    "iMac7,1",
-    "iMac8,1",
-    "Dortania1,1"
 ]
+EthernetMarvell = ["MacBook4,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "Dortania1,1"]
 EthernetBroadcom = [
     "MacBookAir4,1",
     "MacBookAir4,2",
@@ -239,31 +145,14 @@ EthernetBroadcom = [
     "iMac11,3",
     "iMac12,1",
     "iMac12,2",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 # Wifi patches
 
-WifiAtheros = [
+WifiAtheros = ["iMac10,1", "iMac11,1", "iMac11,2", "iMac11,3", "iMac12,1", "iMac12,2", "MacPro3,1", "MacPro4,1", "Dortania1,1"]
-    "iMac10,1",
-    "iMac11,1",
-    "iMac11,2",
-    "iMac11,3",
-    "iMac12,1",
-    "iMac12,2",
-    "MacPro3,1",
-    "MacPro4,1",
-    "Dortania1,1"
-]
 
-WifiBCM94328 = [
+WifiBCM94328 = ["MacBook4,1", "MacBookAir2,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "Dortania1,1"]
-    "MacBook4,1",
-    "MacBookAir2,1",
-    "MacBookPro4,1",
-    "iMac7,1",
-    "iMac8,1",
-    "Dortania1,1"
-]
 
 WifiBCM94322 = [
     "MacBook5,1",
@@ -279,7 +168,7 @@ WifiBCM94322 = [
     "Macmini3,1",
     "iMac9,1",
     "MacPro5,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 WifiBCM94331 = [
@@ -307,7 +196,7 @@ WifiBCM94331 = [
     "iMac13,1",  # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0)
     "iMac13,2",  # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0)
     "iMac13,3",  # PciRoot(0x0)/Pci(0x1C,0x3)/Pci(0x0,0x0)
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 # Audio
@@ -350,7 +239,7 @@ LegacyAudio = [
     "iMac12,1",
     "iMac12,2",
     "MacPro3,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 nvidiaHDEF = [
@@ -370,7 +259,7 @@ nvidiaHDEF = [
     "Macmini3,1",
     "Macmini4,1",
     "iMac9,1",
-    "iMac10,1"
+    "iMac10,1",
 ]
 
 # GPU
@@ -425,7 +314,7 @@ LegacyGPU = [
     "iMac11,3",  # AMD 5000
     "iMac12,1",  # AMD 6000
     "iMac12,2",  # AMD 6000
-    "Dortania1,1"  # RTX 3080
+    "Dortania1,1",  # RTX 3080
 ]
 
 LegacyGPUNvidia = [
@@ -517,15 +406,10 @@ LegacyHID = [
     "iMac9,1",
     "iMac10,1",
     "MacPro3,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
-NVMePatch = [
+NVMePatch = ["MacPro3,1", "MacPro4,1", "Xserve3,1", "Dortania1,1"]
-    "MacPro3,1",
-    "MacPro4,1",
-    "Xserve3,1",
-    "Dortania1,1"
-]
 
 XhciSupport = [
     "MacBookAir5,1",
@@ -557,7 +441,7 @@ XhciSupport = [
     "iMac16,1",
     "iMac16,2",
     "MacPro6,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 SidecarPatch = [
@@ -578,9 +462,16 @@ SidecarPatch = [
     "MacBookPro11,4",
     "MacBookPro11,5",
     "MacBookPro12,1",
+    "MacBookPro13,1",
+    "MacBookPro13,2",
+    "MacBookPro13,3",
+    "MacBookPro14,1",
+    "MacBookPro14,2",
+    "MacBookPro14,3",
     "Macmini6,1",
     "Macmini6,2",
     "Macmini7,1",
+    "Macmini8,1",
     "iMac13,1",
     "iMac13,2",
     "iMac13,3",
@@ -590,9 +481,11 @@ SidecarPatch = [
     "iMac15,1",
     "iMac16,1",
     "iMac16,2",
+    "iMac17,1",
+    "iMac18,1",
     "MacPro5,1",
     "MacPro6,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 DualGPUPatch = [
@@ -610,7 +503,7 @@ DualGPUPatch = [
     "iMac13,2",
     "iMac14,2",
     "iMac14,3",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 DualGPUPatchRetina = [
@@ -625,26 +518,9 @@ IntelNvidiaDRM = [
     "iMac14,3",
 ]
 
-HiDPIpicker = [
+HiDPIpicker = ["MacBook8,1", "MacBookPro10,1", "MacBookPro10,2", "MacBookPro11,1", "MacBookPro11,2", "MacBookPro11,3", "iMac15,1", "Dortania1,1"]
-    "MacBook8,1",
-    "MacBookPro10,1",
-    "MacBookPro10,2",
-    "MacBookPro11,1",
-    "MacBookPro11,2",
-    "MacBookPro11,3",
-    "iMac15,1",
-    "Dortania1,1"
-]
 
-IDEPatch = [
+IDEPatch = ["MacBook4,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "MacPro3,1", "Xserve2,1", "Dortania1,1"]
-    "MacBook4,1",
-    "MacBookPro4,1",
-    "iMac7,1",
-    "iMac8,1",
-    "MacPro3,1",
-    "Xserve2,1",
-    "Dortania1,1"
-]
 
 # 11" Air
 MacBookAir61 = [
@@ -686,9 +562,7 @@ MacBookPro111 = [
 
 # MacBook Pro 15" (iGPU)
 
-MacBookPro112 = [
+MacBookPro112 = ["MacBookPro11,2"]
-    "MacBookPro11,2"
-]
 
 # MacBook Pro 15" and 17" (dGPU)
 
@@ -709,15 +583,7 @@ MacBookPro113 = [
 
 # Mac Mini
 
-Macmini71 = [
+Macmini71 = ["Macmini3,1", "Macmini4,1", "Macmini5,1", "Macmini5,2", "Macmini5,3", "Macmini6,1", "Macmini6,2"]
-    "Macmini3,1",
-    "Macmini4,1",
-    "Macmini5,1",
-    "Macmini5,2",
-    "Macmini5,3",
-    "Macmini6,1",
-    "Macmini6,2"
-]
 # iMacPro = dGPU only iMacs
 iMacPro11 = [
     "iMac7,1",
@@ -739,21 +605,10 @@ iMac151 = [
     "iMac15,1",
 ]
 # iMac = Intel iGPU
-iMac144 = [
+iMac144 = ["iMac13,1", "iMac14,1", "iMac14,4"]
-    "iMac13,1",
-    "iMac14,1",
-    "iMac14,4"
-]
 
 # Mac Pro and Xserve
-MacPro71 = [
+MacPro71 = ["MacPro3,1", "MacPro4,1", "MacPro5,1", "Xserve2,1", "Xserve3,1", "Dortania1,1"]
-    "MacPro3,1",
-    "MacPro4,1",
-    "MacPro5,1",
-    "Xserve2,1",
-    "Xserve3,1",
-    "Dortania1,1"
-]
 
 XXerve = [
     "Xserve3,1",
@@ -848,16 +703,7 @@ ControllerTypes = [
     "-InternalHub",
 ]
 
-upgradableMXMGPUs = [
+upgradableMXMGPUs = ["iMac10,1", "iMac11,1", "iMac11,2", "iMac11,3", "iMac12,1", "iMac12,2", "Xserve3,1", "Dortania1,1"]
-    "iMac10,1"
-    "iMac11,1",
-    "iMac11,2",
-    "iMac11,3",
-    "iMac12,1",
-    "iMac12,2",
-    "Xserve3,1",
-    "Dortania1,1"
-]
 
 NightShift = [
     "MacBook4,1",
@@ -901,7 +747,7 @@ NightShift = [
     "MacPro5,1",
     "Xserve2,1",
     "Xserve3,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 UGAtoGOP = [
@@ -957,7 +803,7 @@ SATAPatch = [
     "MacPro5,1",
     "Xserve2,1",
     "Xserve3,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 NoAPFSsupport = [
@@ -979,7 +825,7 @@ NoAPFSsupport = [
     "MacPro4,1",
     "Xserve2,1",
     "Xserve3,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 NoRootPatch11 = [
@@ -1029,7 +875,7 @@ NoExFat = [
     "MacPro5,1",
     "Xserve2,1",
     "Xserve3,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 SandyIGPU = [
@@ -1067,14 +913,7 @@ windows_audio = [
     "iMac13,3",
 ]
 
-NoAGPMSupport = [
+NoAGPMSupport = ["MacBook4,1", "MacBookPro4,1", "iMac7,1", "iMac8,1", "MacPro3,1", "Xserve2,1"]
-    "MacBook4,1",
-    "MacBookPro4,1",
-    "iMac7,1",
-    "iMac8,1",
-    "MacPro3,1",
-    "Xserve2,1"
-]
 
 AGDPSupport = [
     "MacBookPro9,1",
@@ -1115,211 +954,4 @@ NoFireWireSupport = [
     "MacBookAir3,2",
 ]
 
-DeleteNvidiaAccel11 = [
+RecoveryIgnore = ["Update", "VM", "Recovery", "Preboot"]
-    "AMDRadeonX4000.kext",
-    "AMDRadeonX4000HWServices.kext",
-    "AMDRadeonX5000.kext",
-    "AMDRadeonX5000HWServices.kext",
-    "AMDRadeonX6000.kext",
-    "AMDRadeonX6000Framebuffer.kext",
-    "AMDRadeonX6000HWServices.kext",
-    "AppleIntelBDWGraphics.kext",
-    "AppleIntelBDWGraphicsFramebuffer.kext",
-    "AppleIntelCFLGraphicsFramebuffer.kext",
-    "AppleIntelHD4000Graphics.kext",
-    "AppleIntelHD5000Graphics.kext",
-    "AppleIntelICLGraphics.kext",
-    "AppleIntelICLLPGraphicsFramebuffer.kext",
-    "AppleIntelKBLGraphics.kext",
-    "AppleIntelKBLGraphicsFramebuffer.kext",
-    "AppleIntelSKLGraphics.kext",
-    "AppleIntelSKLGraphicsFramebuffer.kext",
-    "AppleIntelFramebufferAzul.kext",
-    "AppleIntelFramebufferCapri.kext",
-    "AppleParavirtGPU.kext",
-    "GeForce.kext",
-    "IOAcceleratorFamily2.kext",
-    "IOGPUFamily.kext",
-]
-
-DeleteAMDAccel11 = [
-    "AMDRadeonX4000.kext",
-    "AMDRadeonX4000HWServices.kext",
-    "AMDRadeonX5000.kext",
-    "AMDRadeonX5000HWServices.kext",
-    "AMDRadeonX6000.kext",
-    "AMDRadeonX6000Framebuffer.kext",
-    "AMDRadeonX6000HWServices.kext",
-    "AMD7000Controller.kext",  # AMDSupport Dependency
-    "AMD8000Controller.kext",  # AMDSupport Dependency
-    "AMD9000Controller.kext",  # AMDSupport Dependency
-    "AMD9500Controller.kext",  # AMDSupport Dependency
-    "AMD10000Controller.kext",  # AMDSupport Dependency
-    "AppleIntelBDWGraphics.kext",
-    "AppleIntelBDWGraphicsFramebuffer.kext",
-    "AppleIntelCFLGraphicsFramebuffer.kext",
-    "AppleIntelHD4000Graphics.kext",
-    "AppleIntelHD5000Graphics.kext",
-    "AppleIntelICLGraphics.kext",
-    "AppleIntelICLLPGraphicsFramebuffer.kext",
-    "AppleIntelKBLGraphics.kext",
-    "AppleIntelKBLGraphicsFramebuffer.kext",
-    "AppleIntelSKLGraphics.kext",
-    "AppleIntelSKLGraphicsFramebuffer.kext",
-    "AppleIntelFramebufferAzul.kext",
-    "AppleIntelFramebufferCapri.kext",
-    "AppleParavirtGPU.kext",
-    "GeForce.kext",
-    "IOGPUFamily.kext",
-]
-
-DeleteAMDAccel11TS2 = [
-    "AppleCameraInterface.kext",
-]
-
-AddNvidiaAccel11 = [
-    "GeForceGA.bundle",
-    "GeForceTesla.kext",
-    "GeForceTeslaGLDriver.bundle",
-    "GeForceTeslaVADriver.bundle",
-    "NVDANV50HalTesla.kext",
-    "NVDAResmanTesla.kext",
-    "IOSurface.kext",
-]
-
-AddNvidiaBrightness = [
-    "GeForceGA.bundle",
-    "GeForceTesla.kext",
-    "GeForceTeslaGLDriver.bundle",
-    "GeForceTeslaVADriver.bundle",
-    "NVDANV50HalTesla.kext",
-    "NVDAResmanTesla.kext",
-]
-
-AddNvidiaKeplerAccel11 = [
-    "GeForce.kext",
-    "GeForceAIRPlugin.bundle",
-    "GeForceGLDriver.bundle",
-    "GeForceMTLDriver.bundle",
-    "GeForceVADriver.bundle",
-    "NVDAGF100Hal.kext",
-    "NVDAGK100Hal.kext",
-    "NVDAResman.kext",
-    "NVDAStartup.kext",
-    "NVSMU.kext",
-]
-
-AddAMDAccel11 = [
-    "AMD2400Controller.kext",
-    "AMD2600Controller.kext",
-    "AMD3800Controller.kext",
-    "AMD4600Controller.kext",
-    "AMD4800Controller.kext",
-    "AMD5000Controller.kext",
-    "AMD6000Controller.kext",
-    "AMDFramebuffer.kext",
-    "AMDLegacyFramebuffer.kext",
-    "AMDLegacySupport.kext",
-    "AMDRadeonVADriver.bundle",
-    "AMDRadeonVADriver2.bundle",
-    "AMDRadeonX3000.kext",
-    "AMDRadeonX3000GLDriver.bundle",
-    "AMDShared.bundle",
-    "AMDSupport.kext",
-    "ATIRadeonX2000.kext",
-    "ATIRadeonX2000GA.plugin",
-    "ATIRadeonX2000GLDriver.bundle",
-    "ATIRadeonX2000VADriver.bundle",
-]
-
-AddAMDBrightness = [
-    "AMD2400Controller.kext",
-    "AMD2600Controller.kext",
-    "AMD3800Controller.kext",
-    "AMD4600Controller.kext",
-    "AMD4800Controller.kext",
-    "AMD5000Controller.kext",
-    "AMD6000Controller.kext",
-    "AMDLegacyFramebuffer.kext",
-    "AMDLegacySupport.kext",
-    "AMDRadeonVADriver.bundle",
-    "AMDRadeonVADriver2.bundle",
-    #"AMDRadeonX3000.kext",
-    #"AMDRadeonX3000GLDriver.bundle",
-    "AMDShared.bundle",
-    "ATIRadeonX2000.kext",
-    "ATIRadeonX2000GA.plugin",
-    "ATIRadeonX2000GLDriver.bundle",
-    "ATIRadeonX2000VADriver.bundle",
-]
-
-AddAMDAccel11TS2 = [
-    "IOSurface.kext",
-]
-
-AddIntelGen1Accel = [
-    "AppleIntelHDGraphics.kext",
-    "AppleIntelHDGraphicsFB.kext",
-    "AppleIntelHDGraphicsGA.plugin",
-    "AppleIntelHDGraphicsGLDriver.bundle",
-    "AppleIntelHDGraphicsVADriver.bundle",
-]
-
-AddIntelGen2Accel = [
-    "AppleIntelHD3000Graphics.kext",
-    "AppleIntelHD3000GraphicsGA.plugin",
-    "AppleIntelHD3000GraphicsGLDriver.bundle",
-    "AppleIntelHD3000GraphicsVADriver.bundle",
-    "AppleIntelSNBGraphicsFB.kext",
-    "AppleIntelSNBVA.bundle",
-]
-
-AddIntelGen3Accel = [
-    "AppleIntelFramebufferCapri.kext",
-    "AppleIntelHD4000Graphics.kext",
-    "AppleIntelHD4000GraphicsGLDriver.bundle",
-    "AppleIntelHD4000GraphicsMTLDriver.bundle",
-    "AppleIntelHD4000GraphicsVADriver.bundle",
-    "AppleIntelIVBVA.bundle",
-    "AppleIntelGraphicsShared.bundle",
-]
-
-AddGeneralAccel = [
-    # Below 5 from dosdude1, unknown whether they benifit
-    #"AppleGraphicsControl.kext",
-    #"AppleGraphicsPowerManagement.kext",
-    #"AppleMCCSControl.kext",
-    #"IOGraphicsFamily.kext",
-    #"IONDRVSupport.kext",
-    "IOAcceleratorFamily2.kext",
-    "IOSurface.kext"
-]
-
-DeleteBrightness = [
-    "AppleGraphicsControl.kext/Contents/PlugIns/AGDCBacklightControl.kext"
-]
-
-AddBrightness = [
-    "AppleBacklight.kext",
-    "AppleBacklightExpert.kext",
-]
-
-AddVolumeControl = [
-    "AppleHDA.kext",
-    "IOAudioFamily.kext",
-]
-
-DeleteVolumeControl = [
-    "AppleVirtIO.kext",
-    "AppleVirtualGraphics.kext",
-    "AppleVirtualPlatform.kext",
-    "ApplePVPanic.kext",
-    "AppleVirtIOStorage.kext",
-]
-
-RecoveryIgnore = [
-    "Update",
-    "VM",
-    "Recovery",
-    "Preboot"
-]

Resources/SysPatch.py

@@ -5,15 +5,15 @@
 #   - Temporary Work-around: sudo bless --mount /System/Volumes/Update/mnt1 --bootefi --last-sealed-snapshot
 # - Work-around battery throttling on laptops with no battery (IOPlatformPluginFamily.kext/Contents/PlugIns/ACPI_SMC_PlatformPlugin.kext/Contents/Resources/)
 
+import hashlib
 import os
-import plistlib
+import requests
 import shutil
 import subprocess
 import zipfile
 from pathlib import Path
-from typing import Any
 
-from Resources import Constants, DeviceProbe, ModelArray, PCIIDArray, Utilities
+from Resources import Constants, device_probe, ModelArray, SysPatchArray, Utilities
 
 
 class PatchSysVolume:
@@ -48,8 +48,8 @@ class PatchSysVolume:
         self.mount_lauchd = f"{self.mount_location}/System/Library/LaunchDaemons"
         self.mount_private_frameworks = f"{self.mount_location}/System/Library/PrivateFrameworks"
 
-    def elevated(self, *args, **kwargs) -> subprocess.CompletedProcess([Any], returncode=0):
+    def elevated(self, *args, **kwargs) -> subprocess.CompletedProcess:
-        if os.getuid() == 0:
+        if os.getuid() == 0 or self.constants.gui_mode is True:
             return subprocess.run(*args, **kwargs)
         else:
             return subprocess.run(["sudo"] + [args[0][0]] + args[0][1:], **kwargs)
@@ -84,9 +84,11 @@ class PatchSysVolume:
                 else:
                     print("- Failed to mount the Root Volume")
                     print("- Recommend rebooting the machine and trying to patch again")
+                    if self.constants.gui_mode is False:
                         input("- Press [ENTER] to exit: ")
         else:
             print("- Could not find root volume")
+            if self.constants.gui_mode is False:
                 input("- Press [ENTER] to exit: ")
 
     def unpatch_root_vol(self):
@@ -110,6 +112,7 @@ class PatchSysVolume:
             print(result.stdout.decode())
             print("")
             print("\nPlease reboot the machine to avoid potential issues rerunning the patcher")
+            if self.constants.gui_mode is False:
                 input("Press [ENTER] to continue")
         else:
             self.success_status = True
@@ -122,9 +125,9 @@ class PatchSysVolume:
                 self.unmount_drive()
             print("- Patching complete")
             print("\nPlease reboot the machine for patches to take effect")
+            if self.constants.gui_mode is False:
                 input("Press [ENTER] to continue")
 
-
     def unmount_drive(self):
         print("- Unmounting Root Volume (Don't worry if this fails)")
         self.elevated(["diskutil", "unmount", self.root_mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
@@ -150,77 +153,81 @@ class PatchSysVolume:
             self.elevated(["chown", "-Rf", "root:wheel", f"{self.mount_extensions}/{add_current_kext}"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def add_brightness_patch(self):
-        self.delete_old_binaries(ModelArray.DeleteBrightness)
+        self.delete_old_binaries(SysPatchArray.DeleteBrightness)
-        self.add_new_binaries(ModelArray.AddBrightness, self.constants.legacy_brightness)
+        self.add_new_binaries(SysPatchArray.AddBrightness, self.constants.legacy_brightness)
-        self.elevated(["ditto", self.constants.payload_apple_private_frameworks_path_brightness, self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["rsync", "-r", "-i", f"{self.constants.payload_apple_private_frameworks_path_brightness}/", self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         self.elevated(["chmod", "-Rf", "755", f"{self.mount_private_frameworks}/DisplayServices.framework"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         self.elevated(["chown", "-Rf", "root:wheel", f"{self.mount_private_frameworks}/DisplayServices.framework"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def add_audio_patch(self):
-        self.delete_old_binaries(ModelArray.DeleteVolumeControl)
+        self.delete_old_binaries(SysPatchArray.DeleteVolumeControl)
-        self.add_new_binaries(ModelArray.AddVolumeControl, self.constants.audio_path)
+        self.add_new_binaries(SysPatchArray.AddVolumeControl, self.constants.audio_path)
 
-    def gpu_accel_legacy_nvidia(self):
+    def gpu_accel_legacy_nvidia_big_sur(self):
-        self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
+        self.delete_old_binaries(SysPatchArray.DeleteNvidiaAccel11)
-        self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
+        self.add_new_binaries(SysPatchArray.AddGeneralAccel, self.constants.legacy_general_path)
-        self.add_new_binaries(ModelArray.AddNvidiaAccel11, self.constants.legacy_nvidia_path)
+        self.add_new_binaries(SysPatchArray.AddNvidiaAccel11, self.constants.legacy_nvidia_path)
 
     def gpu_framebuffer_legacy_nvidia(self):
-        self.add_new_binaries(ModelArray.AddNvidiaBrightness, self.constants.legacy_nvidia_path)
+        self.add_new_binaries(SysPatchArray.AddNvidiaBrightness, self.constants.legacy_nvidia_path)
 
-    def gpu_accel_legacy_ts1(self):
+    def gpu_accel_legacy_ts1_big_sur(self):
-        self.delete_old_binaries(ModelArray.DeleteAMDAccel11)
+        self.delete_old_binaries(SysPatchArray.DeleteAMDAccel11)
-        self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
+        self.add_new_binaries(SysPatchArray.AddGeneralAccel, self.constants.legacy_general_path)
-        self.add_new_binaries(ModelArray.AddAMDAccel11, self.constants.legacy_amd_path)
+        self.add_new_binaries(SysPatchArray.AddAMDAccel11, self.constants.legacy_amd_path)
 
-    def gpu_accel_legacy_ts2(self):
+    def gpu_accel_legacy_ts2_big_sur(self):
-        self.delete_old_binaries(ModelArray.DeleteAMDAccel11)
+        self.delete_old_binaries(SysPatchArray.DeleteAMDAccel11)
-        self.delete_old_binaries(ModelArray.DeleteAMDAccel11TS2)
+        self.delete_old_binaries(SysPatchArray.DeleteAMDAccel11TS2)
-        self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
+        self.add_new_binaries(SysPatchArray.AddGeneralAccel, self.constants.legacy_general_path)
-        self.add_new_binaries(ModelArray.AddAMDAccel11, self.constants.legacy_amd_path)
+        self.add_new_binaries(SysPatchArray.AddAMDAccel11, self.constants.legacy_amd_path)
 
     def gpu_framebuffer_legacy_amd(self):
-        self.add_new_binaries(ModelArray.AddAMDBrightness, self.constants.legacy_amd_path)
+        self.add_new_binaries(SysPatchArray.AddAMDBrightness, self.constants.legacy_amd_path)
 
-    def gpu_accel_legacy_ironlake(self):
+    def gpu_accel_legacy_ironlake_big_sur(self):
-        self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
+        self.delete_old_binaries(SysPatchArray.DeleteNvidiaAccel11)
-        self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
+        self.add_new_binaries(SysPatchArray.AddGeneralAccel, self.constants.legacy_general_path)
-        self.add_new_binaries(ModelArray.AddIntelGen1Accel, self.constants.legacy_intel_gen1_path)
+        self.add_new_binaries(SysPatchArray.AddIntelGen1Accel, self.constants.legacy_intel_gen1_path)
 
     def gpu_framebuffer_legacy_ironlake(self):
-        self.add_new_binaries(ModelArray.AddIntelGen1Accel, self.constants.legacy_intel_gen1_path)
+        self.add_new_binaries(SysPatchArray.AddIntelGen1Accel, self.constants.legacy_intel_gen1_path)
 
-    def gpu_accel_legacy_sandybridge(self):
+    def gpu_accel_legacy_sandybridge_big_sur(self):
-        self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
+        self.delete_old_binaries(SysPatchArray.DeleteNvidiaAccel11)
-        self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
+        self.add_new_binaries(SysPatchArray.AddGeneralAccel, self.constants.legacy_general_path)
-        self.add_new_binaries(ModelArray.AddIntelGen2Accel, self.constants.legacy_intel_gen2_path)
+        self.add_new_binaries(SysPatchArray.AddIntelGen2Accel, self.constants.legacy_intel_gen2_path)
 
     def gpu_framebuffer_legacy_sandybridge(self):
-        self.add_new_binaries(ModelArray.AddIntelGen2Accel, self.constants.legacy_intel_gen1_path)
+        self.add_new_binaries(SysPatchArray.AddIntelGen2Accel, self.constants.legacy_intel_gen1_path)
 
-    def gpu_framebuffer_ivybridge(self):
+    def gpu_framebuffer_ivybridge_big_sur(self):
-        #self.delete_old_binaries(ModelArray.DeleteAMDAccel11)
+        self.add_new_binaries(SysPatchArray.AddIntelGen3Accel, self.constants.legacy_intel_gen3_path)
-        self.add_new_binaries(ModelArray.AddIntelGen3Accel, self.constants.legacy_intel_gen3_path)
+        print("- Fixing Acceleration in CoreMedia")
-        #self.elevated(["ditto", self.constants.payload_apple_frameworks_path_accel, self.mount_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        subprocess.run(["defaults", "write", "com.apple.coremedia", "hardwareVideoDecoder", "-string", "disable"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        print("- Merging Ivy Bridge Frameworks")
+        self.elevated(["rsync", "-r", "-i", f"{self.constants.payload_apple_frameworks_path_accel_ivy}/", self.mount_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def gpu_accel_legacy_extended(self):
         print("- Merging general legacy Frameworks")
-        self.elevated(["ditto", self.constants.payload_apple_frameworks_path_accel, self.mount_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["rsync", "-r", "-i", f"{self.constants.payload_apple_frameworks_path_accel}/", self.mount_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         if Path(self.mount_lauchd / Path("HiddHack.plist")).exists():
             print("- Removing legacy HiddHack")
             self.elevated(["rm", f"{self.mount_lauchd}/HiddHack.plist"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         print("- Adding IOHID-Fixup.plist")
-        self.elevated(["ditto", self.constants.payload_apple_lauchd_path_accel, self.mount_lauchd], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["rsync", "-r", "-i", f"{self.constants.payload_apple_lauchd_path_accel}/", self.mount_lauchd], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         self.elevated(["chmod", "755", f"{self.mount_lauchd}/IOHID-Fixup.plist"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         self.elevated(["chown", "root:wheel", f"{self.mount_lauchd}/IOHID-Fixup.plist"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         print("- Merging general legacy PrivateFrameworks")
-        self.elevated(["ditto", self.constants.payload_apple_private_frameworks_path_accel, self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["rsync", "-r", "-i", f"{self.constants.payload_apple_private_frameworks_path_accel}/", self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def gpu_accel_legacy_extended_ts2(self):
         print("- Merging TeraScale 2 legacy Frameworks")
-        self.elevated(["ditto", self.constants.payload_apple_frameworks_path_accel_ts2, self.mount_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["rsync", "-r", "-i", f"{self.constants.payload_apple_frameworks_path_accel_ts2}/", self.mount_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
         print("- Merging TeraScale 2 PrivateFrameworks")
-        self.elevated(["ditto", self.constants.payload_apple_private_frameworks_path_accel_ts2, self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["rsync", "-r", "-i", f"{self.constants.payload_apple_private_frameworks_path_accel_ts2}/", self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        print("- Fixing Acceleration in CMIO")
+        subprocess.run(["defaults", "write", "com.apple.cmio", "CMIO_Unit_Input_ASC.DoNotUseOpenCL", "-bool", "true"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def patch_root_vol(self):
         print(f"- Running patches for {self.model}")
@@ -229,7 +236,7 @@ class PatchSysVolume:
             print("- Installing legacy Nvidia Patches")
             if self.constants.detected_os == self.constants.big_sur:
                 print("- Detected Big Sur, installing Acceleration patches")
-                self.gpu_accel_legacy_nvidia()
+                self.gpu_accel_legacy_nvidia_big_sur()
                 self.added_kexts = True
             else:
                 print("- Detected unsupported OS, installing Basic Framebuffer")
@@ -239,7 +246,7 @@ class PatchSysVolume:
             print("- Installing legacy TeraScale 1 Patches")
             if self.constants.detected_os == self.constants.big_sur:
                 print("- Detected Big Sur, installing Acceleration patches")
-                self.gpu_accel_legacy_ts1()
+                self.gpu_accel_legacy_ts1_big_sur()
                 self.added_kexts = True
             else:
                 print("- Detected unsupported OS, installing Basic Framebuffer")
@@ -249,7 +256,7 @@ class PatchSysVolume:
             print("- Installing legacy TeraScale 2 Patches")
             if self.constants.detected_os == self.constants.big_sur:
                 print("- Detected Big Sur, installing Acceleration patches")
-                self.gpu_accel_legacy_ts2()
+                self.gpu_accel_legacy_ts2_big_sur()
                 self.added_kexts = True
             else:
                 print("- Detected unsupported OS, installing Basic Framebuffer")
@@ -259,7 +266,7 @@ class PatchSysVolume:
             print("- Installing legacy Ironlake Patches")
             if self.constants.detected_os == self.constants.big_sur:
                 print("- Detected Big Sur, installing Acceleration patches")
-                self.gpu_accel_legacy_ironlake()
+                self.gpu_accel_legacy_ironlake_big_sur()
                 self.added_kexts = True
             else:
                 print("- Detected unsupported OS, installing Basic Framebuffer")
@@ -269,7 +276,7 @@ class PatchSysVolume:
             print("- Installing legacy Sandy Bridge Patches")
             if self.constants.detected_os == self.constants.big_sur:
                 print("- Detected Big Sur, installing Acceleration patches")
-                self.gpu_accel_legacy_sandybridge()
+                self.gpu_accel_legacy_sandybridge_big_sur()
                 self.added_kexts = True
             else:
                 print("- Detected unsupported OS, installing Basic Framebuffer")
@@ -277,11 +284,11 @@ class PatchSysVolume:
 
         if self.ivy_gpu is True:
             print("- Installing Ivy Bridge Patches")
-            self.gpu_framebuffer_ivybridge()
+            self.gpu_framebuffer_ivybridge_big_sur()
 
         if self.amd_ts2 is True:
             # TeraScale 2 patches must be installed after Intel HD3000
-            self.add_new_binaries(ModelArray.AddAMDAccel11TS2, self.constants.legacy_amd_path_ts2)
+            self.add_new_binaries(SysPatchArray.AddAMDAccel11TS2, self.constants.legacy_amd_path_ts2)
 
         if self.added_kexts is True:
             self.gpu_accel_legacy_extended()
@@ -314,73 +321,77 @@ class PatchSysVolume:
             self.download_files()
 
     def download_files(self):
-        Utilities.cls()
+        if self.constants.detected_os == self.constants.monterey:
-        print("- Downloading Apple binaries")
+            os_ver = "12-Monterey"
-        popen_oclp = subprocess.Popen(
+        elif self.constants.detected_os == self.constants.big_sur:
-            ["curl", "-S", "-L", f"{self.constants.url_apple_binaries}{self.constants.payload_version}.zip", "--output", self.constants.payload_apple_root_path_zip],
+            os_ver = "11-Big-Sur"
-            stdin=subprocess.PIPE,
+        elif self.constants.detected_os == self.constants.catalina:
-            stdout=subprocess.PIPE,
+            os_ver = "10.15-Catalina"
-            stderr=subprocess.STDOUT,
+        elif self.constants.detected_os == self.constants.mojave:
-            universal_newlines=True,
+            os_ver = "10.14-Mojave"
-        )
+        link = f"{self.constants.url_patcher_support_pkg}{self.constants.patcher_support_pkg_version}/{os_ver}.zip"
-        for stdout_line in iter(popen_oclp.stdout.readline, ""):
+
-            print(stdout_line, end="")
+        if Path(self.constants.payload_apple_root_path).exists():
-        popen_oclp.stdout.close()
+            print("- Removing old Apple Binaries folder")
+            Path(self.constants.payload_apple_root_path).unlink()
+        if Path(self.constants.payload_apple_root_path_zip).exists():
+            print("- Removing old Apple Binaries zip")
+            Path(self.constants.payload_apple_root_path_zip).unlink()
+
+        Utilities.download_file(link, self.constants.payload_apple_root_path_zip)
+
         if self.constants.payload_apple_root_path_zip.exists():
             print("- Download completed")
             print("- Unzipping download...")
             try:
                 subprocess.run(["unzip", self.constants.payload_apple_root_path_zip], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.constants.payload_path).stdout.decode()
                 print("- Renaming folder")
-                os.rename(self.constants.payload_apple_root_path_unzip, self.constants.payload_apple_root_path)
+                os.rename(self.constants.payload_path / Path(os_ver), self.constants.payload_apple_root_path)
+                Path(self.constants.payload_apple_root_path_zip).unlink()
                 print("- Binaries downloaded to:")
                 print(self.constants.payload_path)
                 if self.constants.gui_mode is False:
                     input("Press [ENTER] to continue")
             except zipfile.BadZipFile:
                 print("- Couldn't unzip")
-            os.remove(self.constants.payload_apple_root_path_zip)
+                return
         else:
             print("- Download failed, please verify the below link works:")
-            print(f"{self.constants.url_apple_binaries}{self.constants.payload_version}")
+            print(link)
-
+            input("Press [ENTER] to continue")
-
     def detect_gpus(self):
-        igpu_vendor, igpu_device, igpu_acpi = DeviceProbe.pci_probe().gpu_probe("IGPU")
+        dgpu = self.constants.computer.dgpu
-        dgpu_vendor, dgpu_device, dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+        igpu = self.constants.computer.igpu
-        if dgpu_vendor:
+        if dgpu:
-            print(f"- Found GFX0: {dgpu_vendor}:{dgpu_device}")
+            print(f"- Found GFX0: {Utilities.friendly_hex(dgpu.vendor_id)}:{Utilities.friendly_hex(dgpu.device_id)}")
-            if dgpu_vendor == self.constants.pci_nvidia:
+            if dgpu.arch in [device_probe.NVIDIA.Archs.Tesla, device_probe.NVIDIA.Archs.Fermi]:
-                if dgpu_device in PCIIDArray.nvidia_ids().tesla_ids or dgpu_device in PCIIDArray.nvidia_ids().fermi_ids:
                 if self.constants.detected_os > self.constants.catalina:
                     self.nvidia_legacy = True
                     self.amfi_must_disable = True
-            elif dgpu_vendor == self.constants.pci_amd_ati:
+            elif dgpu.arch == device_probe.AMD.Archs.TeraScale_1:
-                if dgpu_device in PCIIDArray.amd_ids().terascale_1_ids:
                 if self.constants.detected_os > self.constants.catalina:
                     self.amd_ts1 = True
                     self.amfi_must_disable = True
             # TODO: Enable TS2 support
-                elif dgpu_device in PCIIDArray.amd_ids().terascale_2_ids:
+            elif dgpu.arch == device_probe.AMD.Archs.TeraScale_2:
                 # Requires manual permission from user to avoid medical issues
-                    if self.constants.detected_os > self.constants.catalina and self.constants.terscale_2_patch is True:
+                if self.constants.detected_os > self.constants.catalina and self.constants.terascale_2_patch is True:
                     self.amd_ts2 = True
                     self.amfi_must_disable = True
-        if igpu_vendor:
+        if igpu and igpu.class_code != 0xFFFFFF:
-            print(f"- Found IGPU: {igpu_vendor}:{igpu_device}")
+            print(f"- Found IGPU: {Utilities.friendly_hex(igpu.vendor_id)}:{Utilities.friendly_hex(igpu.device_id)}")
-            if igpu_vendor == self.constants.pci_intel:
+            if igpu.arch == device_probe.Intel.Archs.Iron_Lake:
-                if igpu_device in PCIIDArray.intel_ids().iron_ids:
                 if self.constants.detected_os > self.constants.catalina:
                     self.iron_gpu = True
                     self.amfi_must_disable = True
-                elif igpu_device in PCIIDArray.intel_ids().sandy_ids:
+            elif igpu.arch == device_probe.Intel.Archs.Sandy_Bridge:
                 if self.constants.detected_os > self.constants.catalina:
                     self.sandy_gpu = True
                     self.amfi_must_disable = True
-                elif igpu_device in PCIIDArray.intel_ids().ivy_ids:
+            elif igpu.arch == device_probe.Intel.Archs.Ivy_Bridge:
                 if self.constants.detected_os > self.constants.big_sur:
                     self.ivy_gpu = True
-            elif igpu_vendor == self.constants.pci_nvidia:
+            elif isinstance(igpu, device_probe.NVIDIA):
                 if self.constants.detected_os > self.constants.catalina:
                     self.nvidia_legacy = True
                     self.amfi_must_disable = True
@@ -414,53 +425,43 @@ class PatchSysVolume:
         if self.legacy_audio is True:
             print("- Add legacy Audio Control")
 
-        if self.nvidia_legacy is False and \
+        self.no_patch = not any(
-            self.amd_ts1 is False and \
+            [
-            self.amd_ts2 is False and \
+                self.nvidia_legacy,
-            self.iron_gpu is False and \
+                self.amd_ts1,
-            self.sandy_gpu is False and \
+                self.amd_ts2,
-            self.ivy_gpu is False and \
+                self.iron_gpu,
-            self.brightness_legacy is False and \
+                self.sandy_gpu,
-            self.legacy_audio is False:
+                self.ivy_gpu,
-            self.no_patch = True
+                self.brightness_legacy,
-        else:
+                self.legacy_audio,
-            self.no_patch = False
+            ]
+        )
 
     def verify_patch_allowed(self):
         self.sip_enabled, self.sbm_enabled, self.amfi_enabled, self.fv_enabled = Utilities.patching_status()
         if self.sip_enabled is True:
-            print("\nCannot patch!!! Please disable SIP!!!")
+            print("\nCannot patch! Please disable System Integrity Protection (SIP).")
-            print("Disable SIP in Patcher Settings and Rebuild OpenCore")
+            print("Disable SIP in Patcher Settings and Rebuild OpenCore\n")
-            print("Ensure the following bits are set for csr-active-config:\n")
+            print("Ensure the following bits are set for csr-active-config:")
-            if self.constants.detected_os > self.constants.catalina:
+            print("\n".join(self.constants.root_patch_sip_big_sur if self.constants.detected_os > self.constants.catalina else self.constants.root_patch_sip_mojave))
-                sip = self.constants.root_patch_sip_big_sur
+            print("For Hackintoshes, please set csr-active-config to '030A0000' (0xA03)")
-            else:
+            print("For non-OpenCore Macs, please run 'csrutil disable' and \n'csrutil authenticated-root disable' in RecoveryOS")
-                sip = self.constants.root_patch_sip_mojave
+
-            print("\n".join(sip))
         if self.sbm_enabled is True:
-            print("\nCannot patch!!! Please disable SecureBootModel!!!")
+            print("\nCannot patch! Please disable Apple Secure Boot.")
             print("Disable SecureBootModel in Patcher Settings and Rebuild OpenCore")
             print("For Hackintoshes, set SecureBootModel to Disabled")
+
         if self.fv_enabled is True:
-            print("\nCannot patch!!! Please disable FileVault!!!")
+            print("\nCannot patch! Please disable FileVault.")
             print("Go to System Preferences -> Security and disable FileVault")
 
         if self.amfi_enabled is True and self.amfi_must_disable is True:
-            print("\nCannot patch!!! Please disable AMFI!!!")
+            print("\nCannot patch! Please disable AMFI.")
             print("For Hackintoshes, please add amfi_get_out_of_my_way=1 to boot-args")
 
-        if self.amfi_must_disable is True:
+        if any([self.sip_enabled, self.sbm_enabled, self.fv_enabled, self.amfi_enabled if self.amfi_must_disable else False]):
-            if self.sip_enabled is True or \
-            self.sbm_enabled is True or \
-            self.amfi_enabled is True or \
-            self.fv_enabled is True:
-                return False
-            else:
-                return True
-        else:
-            if self.sip_enabled is True or \
-            self.sbm_enabled is True or \
-            self.fv_enabled is True:
             return False
         else:
             return True
@@ -470,11 +471,15 @@ class PatchSysVolume:
         print("- Starting Patch Process")
         print(f"- Determinging Required Patch set for Darwin {self.constants.detected_os}")
         self.detect_patch_set()
-        if self.no_patch is False:
+        if self.no_patch is False and self.constants.gui_mode is False:
             change_menu = input("Would you like to continue with Root Volume Patching?(y/n): ")
+        elif self.constants.gui_mode is True:
+            change_menu = "y"
+            print("Continuing root patching")
         else:
             change_menu = None
             print("- No Root Patches required for your machine!")
+            if self.constants.gui_mode is False:
                 input("\nPress [ENTER] to return to the main menu: ")
         if change_menu in ["y", "Y"]:
             print("- Continuing with Patching")
@@ -483,7 +488,7 @@ class PatchSysVolume:
                 print("- Patcher is capable of patching")
                 self.check_files()
                 self.find_mount_root_vol(True)
-            else:
+            elif self.constants.gui_mode is False:
                 input("\nPress [ENTER] to return to the main menu: ")
 
         else:
@@ -493,5 +498,5 @@ class PatchSysVolume:
         print("- Starting Unpatch Process")
         if self.verify_patch_allowed() is True:
             self.find_mount_root_vol(False)
+            if self.constants.gui_mode is False:
                 input("\nPress [ENTER] to return to the main menu")
-

Resources/SysPatchArray.py

@@ -0,0 +1,192 @@
+# Lists Root patches used by SysPatch.py
+# Copyright (C) 2020-2021, Dhinak G, Mykola Grymalyuk
+DeleteNvidiaAccel11 = [
+    "AMDRadeonX4000.kext",
+    "AMDRadeonX4000HWServices.kext",
+    "AMDRadeonX5000.kext",
+    "AMDRadeonX5000HWServices.kext",
+    "AMDRadeonX6000.kext",
+    "AMDRadeonX6000Framebuffer.kext",
+    "AMDRadeonX6000HWServices.kext",
+    "AppleIntelBDWGraphics.kext",
+    "AppleIntelBDWGraphicsFramebuffer.kext",
+    "AppleIntelCFLGraphicsFramebuffer.kext",
+    "AppleIntelHD4000Graphics.kext",
+    "AppleIntelHD5000Graphics.kext",
+    "AppleIntelICLGraphics.kext",
+    "AppleIntelICLLPGraphicsFramebuffer.kext",
+    "AppleIntelKBLGraphics.kext",
+    "AppleIntelKBLGraphicsFramebuffer.kext",
+    "AppleIntelSKLGraphics.kext",
+    "AppleIntelSKLGraphicsFramebuffer.kext",
+    "AppleIntelFramebufferAzul.kext",
+    "AppleIntelFramebufferCapri.kext",
+    "AppleParavirtGPU.kext",
+    "GeForce.kext",
+    "IOAcceleratorFamily2.kext",
+    "IOGPUFamily.kext",
+]
+
+DeleteAMDAccel11 = [
+    "AMDRadeonX4000.kext",
+    "AMDRadeonX4000HWServices.kext",
+    "AMDRadeonX5000.kext",
+    "AMDRadeonX5000HWServices.kext",
+    "AMDRadeonX6000.kext",
+    "AMDRadeonX6000Framebuffer.kext",
+    "AMDRadeonX6000HWServices.kext",
+    "AMD7000Controller.kext",  # AMDSupport Dependency
+    "AMD8000Controller.kext",  # AMDSupport Dependency
+    "AMD9000Controller.kext",  # AMDSupport Dependency
+    "AMD9500Controller.kext",  # AMDSupport Dependency
+    "AMD10000Controller.kext",  # AMDSupport Dependency
+    "AppleIntelBDWGraphics.kext",
+    "AppleIntelBDWGraphicsFramebuffer.kext",
+    "AppleIntelCFLGraphicsFramebuffer.kext",
+    "AppleIntelHD4000Graphics.kext",
+    "AppleIntelHD5000Graphics.kext",
+    "AppleIntelICLGraphics.kext",
+    "AppleIntelICLLPGraphicsFramebuffer.kext",
+    "AppleIntelKBLGraphics.kext",
+    "AppleIntelKBLGraphicsFramebuffer.kext",
+    "AppleIntelSKLGraphics.kext",
+    "AppleIntelSKLGraphicsFramebuffer.kext",
+    "AppleIntelFramebufferAzul.kext",
+    "AppleIntelFramebufferCapri.kext",
+    "AppleParavirtGPU.kext",
+    "GeForce.kext",
+    "IOGPUFamily.kext",
+]
+
+DeleteAMDAccel11TS2 = [
+    "AppleCameraInterface.kext",
+]
+
+AddNvidiaAccel11 = [
+    "GeForceGA.bundle",
+    "GeForceTesla.kext",
+    "GeForceTeslaGLDriver.bundle",
+    "GeForceTeslaVADriver.bundle",
+    "NVDANV50HalTesla.kext",
+    "NVDAResmanTesla.kext",
+    "IOSurface.kext",
+]
+
+AddNvidiaBrightness = [
+    "GeForceGA.bundle",
+    "GeForceTesla.kext",
+    "GeForceTeslaGLDriver.bundle",
+    "GeForceTeslaVADriver.bundle",
+    "NVDANV50HalTesla.kext",
+    "NVDAResmanTesla.kext",
+]
+
+AddNvidiaKeplerAccel11 = [
+    "GeForce.kext",
+    "GeForceAIRPlugin.bundle",
+    "GeForceGLDriver.bundle",
+    "GeForceMTLDriver.bundle",
+    "GeForceVADriver.bundle",
+    "NVDAGF100Hal.kext",
+    "NVDAGK100Hal.kext",
+    "NVDAResman.kext",
+    "NVDAStartup.kext",
+    "NVSMU.kext",
+]
+
+AddAMDAccel11 = [
+    "AMD2400Controller.kext",
+    "AMD2600Controller.kext",
+    "AMD3800Controller.kext",
+    "AMD4600Controller.kext",
+    "AMD4800Controller.kext",
+    "AMD5000Controller.kext",
+    "AMD6000Controller.kext",
+    "AMDFramebuffer.kext",
+    "AMDLegacyFramebuffer.kext",
+    "AMDLegacySupport.kext",
+    "AMDRadeonVADriver.bundle",
+    "AMDRadeonVADriver2.bundle",
+    "AMDRadeonX3000.kext",
+    "AMDRadeonX3000GLDriver.bundle",
+    "AMDShared.bundle",
+    "AMDSupport.kext",
+    "ATIRadeonX2000.kext",
+    "ATIRadeonX2000GA.plugin",
+    "ATIRadeonX2000GLDriver.bundle",
+    "ATIRadeonX2000VADriver.bundle",
+]
+
+AddAMDBrightness = [
+    "AMD2400Controller.kext",
+    "AMD2600Controller.kext",
+    "AMD3800Controller.kext",
+    "AMD4600Controller.kext",
+    "AMD4800Controller.kext",
+    "AMD5000Controller.kext",
+    "AMD6000Controller.kext",
+    "AMDLegacyFramebuffer.kext",
+    "AMDLegacySupport.kext",
+    "AMDRadeonVADriver.bundle",
+    "AMDRadeonVADriver2.bundle",
+    # "AMDRadeonX3000.kext",
+    # "AMDRadeonX3000GLDriver.bundle",
+    "AMDShared.bundle",
+    "ATIRadeonX2000.kext",
+    "ATIRadeonX2000GA.plugin",
+    "ATIRadeonX2000GLDriver.bundle",
+    "ATIRadeonX2000VADriver.bundle",
+]
+
+AddAMDAccel11TS2 = [
+    "IOSurface.kext",
+]
+
+AddIntelGen1Accel = [
+    "AppleIntelHDGraphics.kext",
+    "AppleIntelHDGraphicsFB.kext",
+    "AppleIntelHDGraphicsGA.plugin",
+    "AppleIntelHDGraphicsGLDriver.bundle",
+    "AppleIntelHDGraphicsVADriver.bundle",
+]
+
+AddIntelGen2Accel = [
+    "AppleIntelHD3000Graphics.kext",
+    "AppleIntelHD3000GraphicsGA.plugin",
+    "AppleIntelHD3000GraphicsGLDriver.bundle",
+    "AppleIntelHD3000GraphicsVADriver.bundle",
+    "AppleIntelSNBGraphicsFB.kext",
+    "AppleIntelSNBVA.bundle",
+]
+
+AddIntelGen3Accel = [
+    "AppleIntelFramebufferCapri.kext",
+    "AppleIntelHD4000Graphics.kext",
+    "AppleIntelHD4000GraphicsGLDriver.bundle",
+    "AppleIntelHD4000GraphicsMTLDriver.bundle",
+    "AppleIntelHD4000GraphicsVADriver.bundle",
+    "AppleIntelIVBVA.bundle",
+    "AppleIntelGraphicsShared.bundle",
+]
+
+AddGeneralAccel = ["IOAcceleratorFamily2.kext", "IOSurface.kext"]
+
+DeleteBrightness = ["AppleGraphicsControl.kext/Contents/PlugIns/AGDCBacklightControl.kext"]
+
+AddBrightness = [
+    "AppleBacklight.kext",
+    "AppleBacklightExpert.kext",
+]
+
+AddVolumeControl = [
+    "AppleHDA.kext",
+    "IOAudioFamily.kext",
+]
+
+DeleteVolumeControl = [
+    "AppleVirtIO.kext",
+    "AppleVirtualGraphics.kext",
+    "AppleVirtualPlatform.kext",
+    "ApplePVPanic.kext",
+    "AppleVirtIOStorage.kext",
+]

Resources/Utilities.py

@@ -3,11 +3,16 @@ from __future__ import print_function
 
 import os
 import math
+from pathlib import Path
 import plistlib
 import subprocess
+import requests
+import hashlib
+import requests
 
 from Resources import Constants
 
+
 def hexswap(input_hex: str):
     hex_pairs = [input_hex[i : i + 2] for i in range(0, len(input_hex), 2)]
     hex_rev = hex_pairs[::-1]
@@ -25,12 +30,17 @@ def header(lines):
     print("#" * total_length)
 
 
+RECOVERY_STATUS = None
+
+
 def check_recovery():
-    root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+    global RECOVERY_STATUS  # pylint: disable=global-statement # We need to cache the result
-    if root_partition_info["VolumeName"] == "macOS Base System" and root_partition_info["FilesystemType"] == "apfs" and root_partition_info["BusProtocol"] == "Disk Image":
+
-        return True
+    if RECOVERY_STATUS is None:
-    else:
+        RECOVERY_STATUS = Path("/System/Library/BaseSystem").exists()
-        return False
+
+    return RECOVERY_STATUS
+
 
 def get_disk_path():
     root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
@@ -38,26 +48,29 @@ def get_disk_path():
     root_mount_path = root_mount_path[:-2] if root_mount_path.count("s") > 1 else root_mount_path
     return root_mount_path
 
+
 def csr_decode(csr_active_config):
     if csr_active_config is None:
         csr_active_config = b"\x00\x00\x00\x00"
     sip_int = int.from_bytes(csr_active_config, byteorder="little")
     i = 0
-    for current_sip_bit in Constants.Constants().csr_values:
+    for current_sip_bit in Constants.Constants.csr_values:
         if sip_int & (1 << i):
-            Constants.Constants().csr_values[current_sip_bit] = True
+            Constants.Constants.csr_values[current_sip_bit] = True
         i = i + 1
 
     # Can be adjusted to whatever OS needs patching
-    sip_needs_change = all(
+    sip_needs_change = all(Constants.Constants.csr_values[i] for i in Constants.Constants.root_patch_sip_big_sur)
-        Constants.Constants().csr_values[i]
-        for i in Constants.Constants().root_patch_sip_big_sur
-    )
     if sip_needs_change is True:
         return False
     else:
         return True
 
+
+def friendly_hex(integer: int):
+    return "{:02X}".format(integer)
+
+
 def patching_status():
     # Detection for Root Patching
     sip_enabled = True  # System Integrity Protection
@@ -68,9 +81,9 @@ def patching_status():
     amfi_1 = "amfi_get_out_of_my_way=0x1"
     amfi_2 = "amfi_get_out_of_my_way=1"
 
-    if get_nvram("boot-args", decode=False) and (amfi_1 in get_nvram("boot-args", decode=False) or amfi_2 in get_nvram("boot-args", decode=False)):
+    if get_nvram("boot-args", decode=False) and amfi_1 in get_nvram("boot-args", decode=False) or amfi_2 in get_nvram("boot-args", decode=False):
         amfi_enabled = False
-    if get_nvram("HardwareModel", "94B73556-2197-4702-82A8-3E1337DAFBFB", decode=False) not in Constants.Constants().sbm_values:
+    if get_nvram("HardwareModel", "94B73556-2197-4702-82A8-3E1337DAFBFB", decode=False) not in Constants.Constants.sbm_values:
         sbm_enabled = False
 
     if get_nvram("csr-active-config", decode=False) and csr_decode(get_nvram("csr-active-config", decode=False)) is False:
@@ -82,24 +95,65 @@ def patching_status():
 
     return sip_enabled, sbm_enabled, amfi_enabled, fv_enabled
 
+
+clear = True
+
+
+def disable_cls():
+    global clear
+    clear = False
+
+
 def cls():
-    if check_recovery() == False:
+    global clear
-         os.system('cls' if os.name == 'nt' else 'clear')
+    if not clear:
+        return
+    if not check_recovery():
+        os.system("cls" if os.name == "nt" else "clear")
     else:
         print("\u001Bc")
 
+
 def get_nvram(variable: str, uuid: str = None, *, decode: bool = False):
-    if uuid != None:
+    # TODO: Properly fix for El Capitan, which does not print the XML representation even though we say to
+
+    if uuid is not None:
         uuid += ":"
     else:
         uuid = ""
     result = subprocess.run(f"nvram -x {uuid}{variable}".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.strip()
-    if result:
+    try:
         value = plistlib.loads(result)[f"{uuid}{variable}"]
+    except plistlib.InvalidFileException:
+        return None
     if decode:
         value = value.strip(b"\0").decode()
     return value
-    return None
+
+
+def download_file(link, location):
+    print("- Attempting download from following link:")
+    print(link)
+    if Path(location).exists():
+        print("- Removing old file")
+        Path(location).unlink()
+    response = requests.get(link, stream=True)
+    with location.open("wb") as file:
+        count = 0
+        for chunk in response.iter_content(1024 * 1024 * 4):
+            file.write(chunk)
+            count += len(chunk)
+            cls()
+            print(f"- Downloading package")
+            print(f"- {count / 1024 / 1024}MB Downloaded")
+    checksum = hashlib.sha256()
+    with location.open("rb") as file:
+        chunk = file.read(1024 * 1024 * 16)
+        while chunk:
+            checksum.update(chunk)
+            chunk = file.read(1024 * 1024 * 16)
+    print(f"- Checksum: {checksum.hexdigest()}")
+
 
 # def menu(title, prompt, menu_options, add_quit=True, auto_number=False, in_between=[], top_level=False):
 #     return_option = ["Q", "Quit", None] if top_level else ["B", "Back", None]

Resources/device_probe.py

@@ -0,0 +1,383 @@
+import binascii
+import enum
+import itertools
+import plistlib
+import subprocess
+from dataclasses import dataclass, field
+from typing import Any, ClassVar, Optional, Type
+
+from Resources import PCIIDArray, Utilities, ioreg
+
+
+@dataclass
+class CPU:
+    name: str
+    flags: list[str]
+
+
+@dataclass
+class PCIDevice:
+    VENDOR_ID: ClassVar[int]  # Default vendor id, for subclasses.
+
+    vendor_id: int  # The vendor ID of this PCI device
+    device_id: int  # The device ID of this PCI device
+    class_code: int  # The class code of this PCI device
+
+    # ioregistryentry: Optional[ioreg.IORegistryEntry] = None
+    name: Optional[str] = None  # Name of IORegistryEntry
+    model: Optional[str] = None  # model property
+    pci_path: Optional[str] = None
+
+    # def __getstate__(self):
+    #     state = self.__dict__.copy()
+    #     state.pop("ioregistryentry")
+    #     return state
+
+    @classmethod
+    def from_ioregistry(cls, entry: ioreg.IORegistryEntry, anti_spoof=False):
+        if anti_spoof and "IOName" in entry.properties:
+            vendor_id, device_id = (int(i, 16) for i in entry.properties["IOName"][3:].split(","))
+        else:
+            vendor_id, device_id = [int.from_bytes(entry.properties[i][:4], byteorder="little") for i in ["vendor-id", "device-id"]]
+
+        device = cls(vendor_id, device_id, int.from_bytes(entry.properties["class-code"][:6], byteorder="little"), name=entry.name)
+        if "model" in entry.properties:
+            device.model = entry.properties["model"].strip(b"\0").decode()
+        device.populate_pci_path(entry)
+        return device
+
+    # @staticmethod
+    # def vendor_detect_old(device):
+    #     for i in [NVIDIA, AMD]:
+    #         if i.detect(device):
+    #             return i
+    #     return None
+
+    def vendor_detect(self, *, inherits: ClassVar[Any] = None, classes: list = None):
+        for i in classes or itertools.chain.from_iterable([subclass.__subclasses__() for subclass in PCIDevice.__subclasses__()]):
+            if issubclass(i, inherits or object) and i.detect(self):
+                return i
+        return None
+
+    @classmethod
+    def detect(cls, device):
+        return device.vendor_id == cls.VENDOR_ID and ((device.class_code == cls.CLASS_CODE) if getattr(cls, "CLASS_CODE", None) else True)  # type: ignore  # pylint: disable=no-member
+
+    # def acpi_path(self):
+    #     # Eventually
+    #     raise NotImplementedError
+
+    def populate_pci_path(self, entry: ioreg.IORegistryEntry):
+        # Based off gfxutil logic, seems to work.
+        paths = []
+        while entry:
+            if entry.entry_class == "IOPCIDevice":
+                location = [hex(int(i, 16)) for i in entry.location.split(",") + ["0"]]
+                paths.append(f"Pci({location[0]},{location[1]})")
+            elif entry.entry_class == "IOACPIPlatformDevice":
+                paths.append(f"PciRoot({hex(int(entry.properties.get('_UID', 0)))})")
+                break
+            elif entry.entry_class in ["IOPCI2PCIBridge", "IOPCIBridge", "AppleACPIPCI"]:
+                pass
+            else:
+                # There's something in between that's not PCI! Abort
+                paths = []
+                break
+            entry = entry.parent
+        self.pci_path = "/".join(reversed(paths))
+
+
+@dataclass
+class GPU(PCIDevice):
+    arch: enum.Enum = field(init=False)  # The architecture, see subclasses.
+
+    def __post_init__(self):
+        self.detect_arch()
+
+    def detect_arch(self):
+        raise NotImplementedError
+
+
+@dataclass
+class WirelessCard(PCIDevice):
+    CLASS_CODE: ClassVar[int] = 0x028000  # 00800200 hexswapped
+    country_code: str = field(init=False)
+    chipset: enum.Enum = field(init=False)
+
+    def __post_init__(self):
+        system_profiler = plistlib.loads(subprocess.run("system_profiler -xml SPAirPortDataType".split(), stdout=subprocess.PIPE).stdout)
+        self.country_code = system_profiler[0]["_items"][0]["spairport_airport_interfaces"][0]["spairport_wireless_country_code"]
+        self.detect_chipset()
+
+    def detect_chipset(self):
+        raise NotImplementedError
+
+
+@dataclass
+class NVMeController(PCIDevice):
+    CLASS_CODE: ClassVar[int] = 0x010802
+
+    aspm: Optional[int] = None
+    parent_aspm: Optional[int] = None
+
+
+@dataclass
+class SATAController(PCIDevice):
+    CLASS_CODE: ClassVar[int] = 0x010601
+
+
+@dataclass
+class NVIDIA(GPU):
+    VENDOR_ID: ClassVar[int] = 0x10DE
+
+    class Archs(enum.Enum):
+        # pylint: disable=invalid-name
+        Fermi = "Fermi"
+        Tesla = "Tesla"
+        Kepler = "Kepler"
+        Unknown = "Unknown"
+
+    arch: Archs = field(init=False)
+
+    def detect_arch(self):
+        # G80/G80GL
+        if self.device_id in PCIIDArray.nvidia_ids.tesla_ids:
+            self.arch = NVIDIA.Archs.Tesla
+        elif self.device_id in PCIIDArray.nvidia_ids.fermi_ids:
+            self.arch = NVIDIA.Archs.Fermi
+        elif self.device_id in PCIIDArray.nvidia_ids.kepler_ids:
+            self.arch = NVIDIA.Archs.Kepler
+        else:
+            self.arch = NVIDIA.Archs.Unknown
+
+
+@dataclass
+class AMD(GPU):
+    VENDOR_ID: ClassVar[int] = 0x1002
+
+    class Archs(enum.Enum):
+        # pylint: disable=invalid-name
+        Legacy_GCN = "Legacy GCN"
+        TeraScale_1 = "TeraScale 1"
+        TeraScale_2 = "TeraScale 2"
+        Polaris = "Polaris"
+        Vega = "Vega"
+        Navi = "Navi"
+        Unknown = "Unknown"
+
+    arch: Archs = field(init=False)
+
+    def detect_arch(self):
+        if self.device_id in PCIIDArray.amd_ids.legacy_gcn_ids:
+            self.arch = AMD.Archs.Legacy_GCN
+        elif self.device_id in PCIIDArray.amd_ids.terascale_1_ids:
+            self.arch = AMD.Archs.TeraScale_1
+        elif self.device_id in PCIIDArray.amd_ids.terascale_2_ids:
+            self.arch = AMD.Archs.TeraScale_2
+        elif self.device_id in PCIIDArray.amd_ids.polaris_ids:
+            self.arch = AMD.Archs.Polaris
+        elif self.device_id in PCIIDArray.amd_ids.vega_ids:
+            self.arch = AMD.Archs.Vega
+        elif self.device_id in PCIIDArray.amd_ids.navi_ids:
+            self.arch = AMD.Archs.Navi
+        else:
+            self.arch = AMD.Archs.Unknown
+
+
+@dataclass
+class Intel(GPU):
+    VENDOR_ID: ClassVar[int] = 0x8086
+
+    class Archs(enum.Enum):
+        # pylint: disable=invalid-name
+        Iron_Lake = "Iron Lake"
+        Sandy_Bridge = "Sandy Bridge"
+        Ivy_Bridge = "Ivy Bridge"
+        Unknown = "Unknown"
+
+    arch: Archs = field(init=False)
+
+    def detect_arch(self):
+        if self.device_id in PCIIDArray.intel_ids.iron_ids:
+            self.arch = Intel.Archs.Iron_Lake
+        elif self.device_id in PCIIDArray.intel_ids.sandy_ids:
+            self.arch = Intel.Archs.Sandy_Bridge
+        elif self.device_id in PCIIDArray.intel_ids.ivy_ids:
+            self.arch = Intel.Archs.Ivy_Bridge
+        else:
+            self.arch = Intel.Archs.Unknown
+
+
+@dataclass
+class Broadcom(WirelessCard):
+    VENDOR_ID: ClassVar[int] = 0x14E4
+
+    class Chipsets(enum.Enum):
+        # pylint: disable=invalid-name
+        AirportBrcmNIC = "AirportBrcmNIC supported"
+        AirPortBrcm4360 = "AirPortBrcm4360 supported"
+        AirPortBrcm4331 = "AirPortBrcm4331 supported"
+        AirPortBrcm43224 = "AppleAirPortBrcm43224 supported"
+        Unknown = "Unknown"
+
+    chipset: Chipsets = field(init=False)
+
+    def detect_chipset(self):
+        if self.device_id in PCIIDArray.broadcom_ids.AirPortBrcmNIC:
+            self.chipset = Broadcom.Chipsets.AirportBrcmNIC
+        elif self.device_id in PCIIDArray.broadcom_ids.AirPortBrcm4360:
+            self.chipset = Broadcom.Chipsets.AirPortBrcm4360
+        elif self.device_id in PCIIDArray.broadcom_ids.AirPortBrcm4331:
+            self.chipset = Broadcom.Chipsets.AirPortBrcm4331
+        elif self.device_id in PCIIDArray.broadcom_ids.AppleAirPortBrcm43224:
+            self.chipset = Broadcom.Chipsets.AirPortBrcm43224
+        else:
+            self.chipset = Broadcom.Chipsets.Unknown
+
+
+@dataclass
+class Atheros(WirelessCard):
+    VENDOR_ID: ClassVar[int] = 0x168C
+
+    class Chipsets(enum.Enum):
+        # pylint: disable=invalid-name
+        # Well there's only one model but
+        AirPortAtheros40 = "AirPortAtheros40 supported"
+        Unknown = "Unknown"
+
+    chipset: Chipsets = field(init=False)
+
+    def detect_chipset(self):
+        if self.device_id in PCIIDArray.atheros_ids.AtherosWifi:
+            self.chipset = Atheros.Chipsets.AirPortAtheros40
+        else:
+            self.chipset = Atheros.Chipsets.Unknown
+
+
+@dataclass
+class Computer:
+    real_model: Optional[str] = None
+    real_board_id: Optional[str] = None
+    reported_model: Optional[str] = None
+    reported_board_id: Optional[str] = None
+    gpus: list[GPU] = field(default_factory=list)
+    igpu: Optional[GPU] = None  # Shortcut for IGPU
+    dgpu: Optional[GPU] = None  # Shortcut for GFX0
+    storage: list[PCIDevice] = field(default_factory=list)
+    wifi: Optional[WirelessCard] = None
+    cpu: Optional[CPU] = None
+    oclp_version: Optional[str] = None
+    ioregistry: Optional[ioreg.IOReg] = None
+
+    @staticmethod
+    def probe():
+        computer = Computer()
+        computer.ioregistry = ioreg.IOReg()
+        computer.gpu_probe()
+        computer.dgpu_probe()
+        computer.igpu_probe()
+        computer.wifi_probe()
+        computer.storage_probe()
+        computer.smbios_probe()
+        computer.cpu_probe()
+        return computer
+
+    def gpu_probe(self):
+        # Chain together two iterators: one for class code 00000300, the other for class code 00800300
+        devices = itertools.chain(self.ioregistry.find(property=("class-code", binascii.a2b_hex("00000300"))), self.ioregistry.find(property=("class-code", binascii.a2b_hex("00800300"))))
+
+        for device in devices:
+            vendor: Type[GPU] = PCIDevice.from_ioregistry(device).vendor_detect(inherits=GPU)  # type: ignore
+            if vendor:
+                self.gpus.append(vendor.from_ioregistry(device))  # type: ignore
+
+    def dgpu_probe(self):
+        device = next(self.ioregistry.find(name="GFX0"), None)
+        if not device:
+            # No devices
+            return
+
+        vendor: Type[GPU] = PCIDevice.from_ioregistry(device).vendor_detect(inherits=GPU)  # type: ignore
+        if vendor:
+            self.dgpu = vendor.from_ioregistry(device)  # type: ignore
+
+    def igpu_probe(self):
+        device = next(self.ioregistry.find(name="IGPU"), None)
+        if not device:
+            # No devices
+            return
+
+        vendor: Type[GPU] = PCIDevice.from_ioregistry(device).vendor_detect(inherits=GPU)  # type: ignore
+        if vendor:
+            self.igpu = vendor.from_ioregistry(device)  # type: ignore
+
+    def wifi_probe(self):
+        # result = subprocess.run("ioreg -r -c IOPCIDevice -a -d2".split(), stdout=subprocess.PIPE).stdout.strip()
+        devices = self.ioregistry.find(property=("class-code", binascii.a2b_hex(Utilities.hexswap(hex(WirelessCard.CLASS_CODE)[2:].zfill(8)))))
+        # if not result:
+        #     # No devices
+        #     print("A")
+        #     return
+
+        # devices = plistlib.loads(result)
+        # devices = [i for i in devices if i["class-code"] == binascii.a2b_hex("00800200")]
+
+        # if not devices:
+        #     # No devices
+        #     print("B")
+        #     return
+
+        for device in devices:
+            vendor: Type[WirelessCard] = PCIDevice.from_ioregistry(device, anti_spoof=True).vendor_detect(inherits=WirelessCard)  # type: ignore
+            if vendor:
+                self.wifi = vendor.from_ioregistry(device, anti_spoof=True)  # type: ignore
+                break
+
+    def storage_probe(self):
+        sata_controllers = self.ioregistry.find(entry_class="IOPCIDevice", property=("class-code", binascii.a2b_hex(Utilities.hexswap(hex(SATAController.CLASS_CODE)[2:].zfill(8)))))
+        nvme_controllers = itertools.chain.from_iterable(
+            [
+                # self.ioregistry.find(entry_class="IOPCIDevice", property=("class-code", binascii.a2b_hex(Utilities.hexswap(hex(NVMeController.CLASS_CODE)[2:].zfill(8))))),
+                self.ioregistry.find(entry_class="IOPCIDevice", children={"entry_class": "IONVMeController"}),
+            ]
+        )
+        for device in sata_controllers:
+            self.storage.append(SATAController.from_ioregistry(device))
+        for device in nvme_controllers:
+            aspm = device.properties.get("pci-aspm-default", 0)
+            if isinstance(aspm, bytes):
+                aspm = int.from_bytes(aspm, byteorder="little")
+
+            if device.parent.parent.entry_class == "IOPCIDevice":
+                parent_aspm = device.parent.parent.properties.get("pci-aspm-default", 0)
+                if isinstance(parent_aspm, bytes):
+                    parent_aspm = int.from_bytes(parent_aspm, byteorder="little")
+            else:
+                parent_aspm = None
+
+            controller = NVMeController.from_ioregistry(device)
+            controller.aspm = aspm
+            controller.parent_aspm = parent_aspm
+
+            if controller.vendor_id != 0x106B:
+                self.storage.append(controller)
+
+    def smbios_probe(self):
+        # Reported model
+        entry = next(self.ioregistry.find(name="Root")).children[0]
+        self.reported_model = entry.properties["model"].strip(b"\0").decode()
+        self.reported_board_id = entry.properties.get("board-id", entry.properties.get("target-type", b"")).strip(b"\0").decode()
+
+        # Real model
+        # TODO: We previously had logic for OC users using iMacPro1,1 with incorrect ExposeSensitiveData. Add logic?
+        self.real_model = Utilities.get_nvram("oem-product", "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102", decode=True) or self.reported_model
+        self.real_board_id = Utilities.get_nvram("oem-board", "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102", decode=True) or self.reported_board_id
+
+        # OCLP version
+        self.oclp_version = Utilities.get_nvram("OCLP-Version", "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102", decode=True)
+
+    def cpu_probe(self):
+        self.cpu = CPU(
+            subprocess.run("sysctl machdep.cpu.brand_string".split(), stdout=subprocess.PIPE).stdout.decode().partition(": ")[2].strip(),
+            subprocess.run("sysctl machdep.cpu.features".split(), stdout=subprocess.PIPE).stdout.decode().partition(": ")[2].strip().split(" "),
+        )

Resources/ioreg.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import plistlib
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Generator
+from xml.parsers.expat import ExpatError
+
+
+@dataclass
+class IORegistryEntry:
+    name: str
+    entry_class: str
+    properties: dict
+    location: str
+    children: list[IORegistryEntry]
+    parent: IORegistryEntry
+
+
+class IOReg:
+    def __init__(self):
+        try:
+            self.ioreg = plistlib.loads(subprocess.run("ioreg -a -l".split(), stdout=subprocess.PIPE).stdout.strip())
+        except ExpatError:
+            fd, file_path = tempfile.mkstemp(suffix=".plist")
+            with open(fd, "wb") as file_obj:
+                file_obj.write(subprocess.run("ioreg -a -l".split(), stdout=subprocess.PIPE).stdout.strip())
+
+            subprocess.run("plutil -convert binary1".split() + [file_path])
+            self.ioreg = plistlib.load(Path(file_path).open("rb"))
+        self.tree = self.recurse(self.ioreg, None)
+
+    def recurse(self, entry, parent):
+        converted = IORegistryEntry(
+            entry["IORegistryEntryName"],
+            entry["IOObjectClass"],
+            {
+                i: v
+                for i, v in entry.items()
+                if i
+                not in [
+                    "IOServiceBusyState",
+                    "IOServiceBusyTime",
+                    "IOServiceState",
+                    "IORegistryEntryLocation",
+                    "IORegistryEntryName",
+                    "IORegistryEntryID",
+                    "IOObjectClass",
+                    "IORegistryEntryChildren",
+                    "IOObjectRetainCount",
+                ]
+            },
+            entry.get("IORegistryEntryLocation"),
+            [],
+            parent,
+        )
+
+        for i in entry.get("IORegistryEntryChildren", []):
+            converted.children.append(self.recurse(i, converted))
+
+        return converted
+
+    def parse_conditions(self, entry: IORegistryEntry, **kwargs):
+        conditions = []
+        if "parent" in kwargs:
+            conditions.append(self.parse_conditions(entry.parent, **kwargs["parent"]))
+        if "children" in kwargs:
+            conditions.append(any(self.parse_conditions(i, **kwargs["children"]) for i in entry.children))
+        if "name" in kwargs:
+            conditions.append(kwargs["name"] == entry.name)
+        if "entry_class" in kwargs:
+            conditions.append(kwargs["entry_class"] == entry.entry_class)
+        if "key" in kwargs:
+            conditions.append(kwargs["key"] in entry.properties)
+        if "property" in kwargs:
+            conditions.append(kwargs["property"][0] in entry.properties and entry.properties[kwargs["property"][0]] == kwargs["property"][1])
+
+        return all(conditions)
+
+    def find(self, root: IORegistryEntry = None, **kwargs) -> Generator[IORegistryEntry, None, None]:
+        if not root:
+            root = self.tree
+
+        if not kwargs:
+            return
+
+        if self.parse_conditions(root, **kwargs):
+            yield root
+
+        for i in root.children:
+            for j in self.find(i, **kwargs):
+                yield j

docs/.vuepress/config.js

@@ -93,6 +93,14 @@ module.exports = {
             ]
 
         },
+        {
+            title: 'macOS Monterey',
+            collapsable: false,
+            sidebarDepth: 1,
+            children: [
+				'MONTEREY-DROP',
+            ]
+        },
         {
             title: 'Misc',
             collapsable: false,

docs/MONTEREY-DROP.md

@@ -0,0 +1,120 @@
+# macOS Monterey Support
+
+With OpenCore Legacy Patcher v0.1.7 and newer, we've implemented beta macOS Monterey support for users. Please note that Apple has dropped a lot of hardware with this release as well as broken many of our previous patch sets. This page will be used to inform users regarding current issues and will be updated as new patch sets are developed and added to our patcher.
+
+Current models with full, unhindered support in OpenCore Legacy Patcher are the following:
+
+* iMac13,x and newer
+  * iMac10,1-12,x included if Wireless Card and Bluetooth upgraded as well as Metal GPU
+* Macmini7,1 and newer
+* MacBook8,1 and newer
+* MacBookAir6,x and newer
+* MacBookPro11,x and newer
+* MacPro3,1 and newer
+  * Requires Wireless Card and Bluetooth upgrade for 3,1-5,1 as well as Metal GPU
+
+## Current Hardware Drawbacks:
+
+Below is a list of hardware that currently has issues with Monterey:
+
+* [Acceleration Support Dropped](#acceleration-support-dropped)
+  * [Metal GPUs](#metal-gpus)
+  * [Non-Metal GPUs](#non-metal-gpus)
+* [Bluetooth Support Dropped](#bluetooth-support-dropped)
+* [Wireless Support Dropped](#wireless-support-dropped)
+
+## Acceleration Support Dropped
+
+### Metal GPUs
+
+* Intel HD4000 iGPUs lost support
+
+By default these machines require root volume patches to gain graphics acceleration in Monterey. OpenCore Legacy Patcher supports readding support however SIP and FileVault can no longer be enabled due to root patching:
+
+* Macmini6,x
+* MacBookAir5,x
+* MacBookPro9,x
+* MacBookPro10,x
+
+Note: Currently HD 4000 support in Monterey is not perfect, following are broken:
+
+::: details HD 4000 Issues
+
+* Photo Booth app crashing
+* Safari sites crash if request camera access
+* Full Screen recoding crashing with Screenshot app
+* AirPlay to Mac crashes
+* Full Screen apps crashes
+  * Disable "Hide menubar in Full Screen" to avoid crash
+
+:::
+
+### Non-Metal GPUs
+
+* Non-Metal GPUs no longer have working acceleration patches:
+  * Intel Ironlake and Sandy Bridge iGPUs
+  * Nvidia Tesla and Fermi GPUs
+  * AMD TeraScale 1 and 2 GPUs
+
+The following machines cannot gain graphics acceleration at all in Monterey, only basic framebuffer and brightness control (iMac8,1/9,1 and MacBook5,2 excluded):
+
+* iMac12,x and older
+* Macmini5,x and older
+* MacBook7,1 and older
+* MacBookAir4,x and older
+* MacBookPro8,x and older
+
+Note: iMac10,1 through iMac12,x can be upgraded with Metal GPUs, [see here for more info](https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/)
+
+## Bluetooth Support Dropped 
+
+* BRCM2046 and BRCM2070 Bluetooth Chipsets lost support
+
+The following models lost Bluetooth support in macOS Monterey due to their legacy Bluetooth chipset:
+
+* iMac12,x and older
+* Macmini5,1 and older
+* MacBook7,1 and older
+* MacBookAir4,1 and older
+* MacBookPro8,1 and older
+* MacPro5,1 and older
+
+::: details Dropped Firmwares 
+
+Here are the firmwares macOS Monterey Dropped (previously located within IOBluetoothUSBDFU.kext):
+
+* 2046_820F.dfu
+* 2046_8210.dfu
+* 2046_8213.dfu
+* 2046_8215.dfu
+* 2046_8216.dfu
+* 2046_8217.dfu
+* 2070_821A.dfu
+* 2070_821B.dfu
+* 2070_8218.dfu
+* 20702_821D.dfu
+* 20702_821F.dfu
+* 20702_828A.dfu
+* 20702_828B.dfu
+* 20702_828C.dfu
+* 20702_8281.dfu
+* 20702_8286.dfu
+
+:::
+
+Note: Native BRCM20702 and BRCM20703 are still fully support by OpenCore Legacy Patcher
+
+## Wireless Support Dropped
+
+* Broadcom BCM94328, BCM94322 and Atheros Wireless Chipsets lost support
+
+The following models lost Bluetooth support in macOS Monterey due to their legacy Wireless chipset:
+
+* iMac12,x and older
+* Macmini3,1 and older
+* MacBook5,x and older
+* MacBookAir2,1 and older
+* MacBookPro7,1 and older
+* MacPro5,1 and older
+
+Note: BCM943224, BCM94331, BCM94360 and BCM943602 are still fully support by OpenCore Legacy Patcher

docs/POST-INSTALL.md

@@ -28,6 +28,12 @@ Here you can change different patcher settings, however the main interest is:
 
 Once you've toggled them both off, build your OpenCore EFI once again and install to your desired drive. Now to show the OpenCore selector, you can simply hold down the "ESC" key while clicking on EFI boot, then you can release the "ESC" key when you see the cursor arrow at the top left.
 
+## Enabling SIP
+
+For many users, SIP will be enabled by default on build. For Intel HD 4000 users, you may have noticed that SIP is disabled. This is to ensure full compatibility with macOS Monterey and allow seamless booting between it and older OSes. However for users who do not plan to boot Monterey, you can re-enable under Patcher Settings.
+
+Note: Machines with non-Metal GPUs cannot enable SIP in Big Sur either due to patched root volume
+
 ## Applying Post Install Volume Patches
 
 **Note**: For users who need Post-Install Volume patches for legacy video acceleration support, you **must** disable the following settings in "Patcher Settings" when building and installing your new OpenCore:

entitlements.plist

@@ -4,5 +4,7 @@
 <dict>
 	<key>com.apple.security.cs.disable-library-validation</key>
 	<true/>
+	<key>com.apple.security.cs.disable-executable-page-protection</key>
+	<true/>
 </dict>
 </plist>

payloads/Config/config.plist

@@ -1101,7 +1101,7 @@
 			<key>LauncherOption</key>
 			<string>Full</string>
 			<key>PickerAttributes</key>
-			<integer>17</integer>
+			<integer>145</integer>
 			<key>PickerAudioAssist</key>
 			<false/>
 			<key>PickerMode</key>
@@ -1231,8 +1231,6 @@
 			</dict>
 			<key>7C436110-AB2A-4BBB-A880-FE41995C9F82</key>
 			<dict>
-				<key>SystemAudioVolume</key>
-				<data>Rg==</data>
 				<key>boot-args</key>
 				<string>keepsyms=1 debug=0x100 -lilubetaall</string>
 				<key>csr-active-config</key>

requirements.txt

@@ -0,0 +1 @@
+requests