amd-debug-tools 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

amd_debug/common.py

@@ -81,6 +81,15 @@ def print_color(message, group) -> None:
     print(f"{prefix}{color}{message}{suffix}")
 
 
+def colorize_choices(choices, default) -> str:
+    """Output a list of choices with colors, where the default is highlighted"""
+    if default not in choices:
+        raise ValueError(f"Default choice '{default}' not in choices")
+    choices = [c for c in choices if c != default]
+    choices = [f"{Colors.OK}{default}{Colors.ENDC}"] + choices
+    return ", ".join(choices)
+
+
 def fatal_error(message):
     """Prints a fatal error message and exits"""
     _configure_log(None)
@@ -88,6 +97,21 @@ def fatal_error(message):
     sys.exit(1)
 
 
+def apply_prefix_wrapper(header, message):
+    """Apply a prefix to wrap a newline delimitted message"""
+    s = f"{header.strip()}\n"
+    lines = message.strip().split("\n")
+    for i, line in enumerate(lines):
+        line = line.strip()
+        if not line:
+            continue
+        if i == len(lines) - 1:
+            s += f"└─ {line}\n"
+            continue
+        s += f"│ {line}\n"
+    return s
+
+
 def show_log_info():
     """Show log information"""
     logger = logging.getLogger()

amd_debug/display.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+"""Display analysis"""
+import os
+from pyudev import Context
+
+from amd_debug.common import read_file
+
+
+class Display:
+    """Display analysis"""
+
+    def __init__(self):
+        self.pyudev = Context()
+        self.edid = {}
+
+        for dev in self.pyudev.list_devices(subsystem="drm"):
+            if not "card" in dev.device_path:
+                continue
+            p = os.path.join(dev.sys_path, "status")
+            if not os.path.exists(p):
+                continue
+            f = read_file(p)
+            if f != "connected":
+                continue
+            p = os.path.join(dev.sys_path, "enabled")
+            f = read_file(p)
+            if f != "enabled":
+                continue
+            self.edid[dev.sys_name] = os.path.join(dev.sys_path, "edid")
+
+    def get_edid(self) -> list:
+        """Get the path for EDID data for all connected displays"""
+        return self.edid

amd_debug/installer.py

@@ -1,6 +1,10 @@
 #!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
+"""
+This module contains installer support for amd-debug-tools.
+"""
+
 import argparse
 import os
 import shutil
@@ -21,6 +25,7 @@ class Headers:  # pylint: disable=too-few-public-methods
     """Headers for the script"""
 
     MissingIasl = "ACPI extraction tool `iasl` is missing"
+    MissingEdidDecode = "EDID decoding tool `edid-decode` is missing"
     MissingEthtool = "Ethtool is missing"
     InstallAction = "Attempting to install"
     MissingFwupd = "Firmware update library `fwupd` is missing"
@@ -171,6 +176,18 @@ class EthtoolPackage(DistroPackage):
         )
 
 
+class EdidDecodePackage(DistroPackage):
+    """Edid-Decode package"""
+
+    def __init__(self):
+        super().__init__(
+            deb="edid-decode",
+            rpm="edid-decode",
+            arch=None,
+            message=Headers.MissingEdidDecode,
+        )
+
+
 class FwupdPackage(DistroPackage):
     """Fwupd package"""
 
@@ -202,14 +219,14 @@ class Installer(AmdTool):
         # test if fwupd can report device firmware versions
         try:
             import gi  # pylint: disable=import-outside-toplevel
-            from gi.repository import (
+            from gi.repository import (  # pylint: disable=import-outside-toplevel
                 GLib as _,
-            )  # pylint: disable=import-outside-toplevel
+            )
 
             gi.require_version("Fwupd", "2.0")
-            from gi.repository import (
+            from gi.repository import (  # pylint: disable=import-outside-toplevel
                 Fwupd as _,
-            )  # pylint: disable=import-outside-toplevel
+            )
 
             self.fwupd = True
         except ImportError:
@@ -244,6 +261,20 @@ class Installer(AmdTool):
                 package = EthtoolPackage()
                 if not package.install():
                     return False
+        if "edid-decode" in self.requirements:
+            try:
+                edid = (
+                    subprocess.call(
+                        ["edid-decode", "--help"], stdout=subprocess.DEVNULL
+                    )
+                    == 255
+                )
+            except FileNotFoundError:
+                edid = False
+            if not edid:
+                package = EdidDecodePackage()
+                if not package.install():
+                    return False
         if "fwupd" in self.requirements and not self.fwupd:
             package = FwupdPackage()
             if not package.install():
@@ -396,6 +427,7 @@ def install_dep_superset() -> bool:
         "pandas",
         "seaborn",
         "tabulate",
+        "edid-decode",
     )
     ret = tool.install_dependencies()
     if ret:

amd_debug/prerequisites.py

@@ -1,6 +1,11 @@
 #!/usr/bin/python3
 # SPDX-License-Identifier: MIT
 
+"""
+This module contains the s0i3 prerequisite validator for amd-debug-tools.
+"""
+
+import configparser
 import logging
 import os
 import platform
@@ -9,13 +14,16 @@ import shutil
 import subprocess
 import tempfile
 import struct
-import pyudev
 from datetime import datetime
 from packaging import version
 
+import pyudev
+
 from amd_debug.wake import WakeIRQ
+from amd_debug.display import Display
 from amd_debug.kernel import get_kernel_log, SystemdLogger, DmesgLogger
 from amd_debug.common import (
+    apply_prefix_wrapper,
     BIT,
     clear_temporary_message,
     get_distro,
@@ -111,12 +119,37 @@ class PrerequisiteValidator(AmdTool):
         self.irqs = []
         self.smu_version = ""
         self.smu_program = ""
+        self.display = Display()
 
     def capture_once(self):
         """Capture the prerequisites once"""
         if not self.db.get_last_prereq_ts():
             self.run()
 
+    def capture_edid(self):
+        """Capture and decode the EDID data"""
+        edids = self.display.get_edid()
+        if len(edids) == 0:
+            self.db.record_debug("No EDID data found")
+            return True
+
+        for name, p in edids.items():
+            try:
+                cmd = ["edid-decode", p]
+                output = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode(
+                    "utf-8"
+                )
+            except FileNotFoundError:
+                self.db.record_prereq(
+                    "edid-decode not installed, unable to decode EDID", "👀"
+                )
+                return True
+            except subprocess.CalledProcessError as e:
+                self.db.record_prereq(f"Failed to capture EDID table: {e.output}", "👀")
+                return False
+            self.db.record_debug(apply_prefix_wrapper(f"EDID for {name}:", output))
+        return True
+
     def check_amdgpu(self):
         """Check for the AMDGPU driver"""
         for device in self.pyudev.list_devices(subsystem="pci"):
@@ -167,10 +200,10 @@ class PrerequisiteValidator(AmdTool):
         if self.kernel_log.match_pattern("ath11k_pci.*wcn6855"):
             match = self.kernel_log.match_pattern("ath11k_pci.*fw_version")
             if match:
-                self.db.record_debug("WCN6855 version string: %s" % match)
+                self.db.record_debug(f"WCN6855 version string: {match}")
                 objects = match.split()
-                for i in range(0, len(objects)):
-                    if objects[i] == "fw_build_id":
+                for i, obj in enumerate(objects):
+                    if obj == "fw_build_id":
                         wcn6855 = objects[i + 1]
 
         if wcn6855:
@@ -346,6 +379,7 @@ class PrerequisiteValidator(AmdTool):
 
     def check_usb3(self):
         """Check for the USB4 controller"""
+        slots = []
         for device in self.pyudev.list_devices(subsystem="pci", PCI_CLASS="C0330"):
             slot = device.properties["PCI_SLOT_NAME"]
             if device.properties.get("DRIVER") != "xhci_hcd":
@@ -354,18 +388,27 @@ class PrerequisiteValidator(AmdTool):
                 )
                 self.failures += [MissingXhciHcd()]
                 return False
-            self.db.record_prereq(f"USB3 driver `xhci_hcd` bound to {slot}", "✅")
+            slots += [slot]
+        if slots:
+            self.db.record_prereq(
+                f"USB3 driver `xhci_hcd` bound to {', '.join(slots)}", "✅"
+            )
         return True
 
     def check_usb4(self):
         """Check if the thunderbolt driver is loaded"""
+        slots = []
         for device in self.pyudev.list_devices(subsystem="pci", PCI_CLASS="C0340"):
             slot = device.properties["PCI_SLOT_NAME"]
             if device.properties.get("DRIVER") != "thunderbolt":
                 self.db.record_prereq("USB4 driver `thunderbolt` missing", "❌")
                 self.failures += [MissingThunderbolt()]
                 return False
-            self.db.record_prereq(f"USB4 driver `thunderbolt` bound to {slot}", "✅")
+            slots += [slot]
+        if slots:
+            self.db.record_prereq(
+                f"USB4 driver `thunderbolt` bound to {', '.join(slots)}", "✅"
+            )
         return True
 
     def check_sleep_mode(self):
@@ -478,8 +521,8 @@ class PrerequisiteValidator(AmdTool):
                 continue
             if self.cpu_family and self.cpu_model and self.cpu_model_string:
                 self.db.record_prereq(
-                    "%s (family %x model %x)"
-                    % (self.cpu_model_string, self.cpu_family, self.cpu_model),
+                    f"{self.cpu_model_string} "
+                    f"(family {self.cpu_family:x} model {self.cpu_model:x})",
                     "💻",
                 )
                 break
@@ -487,7 +530,7 @@ class PrerequisiteValidator(AmdTool):
 
     # See https://github.com/torvalds/linux/commit/ec6c0503190417abf8b8f8e3e955ae583a4e50d4
     def check_fadt(self):
-        """Check the kernel emitted a message specific to 6.0 or later indicating FADT had a bit set."""
+        """Check the kernel emitted a message indicating FADT had a bit set."""
         found = False
         if not self.kernel_log:
             message = "Unable to test FADT from kernel log"
@@ -575,10 +618,10 @@ class PrerequisiteValidator(AmdTool):
         """Check if the user has permissions to write to /sys/power/state"""
         p = os.path.join("/", "sys", "power", "state")
         try:
-            with open(p, "w") as w:
+            with open(p, "w", encoding="utf-8") as _w:
                 pass
         except PermissionError:
-            self.db.record_prereq("%s" % Headers.RootError, "👀")
+            self.db.record_prereq(f"{Headers.RootError}", "👀")
             return False
         except FileNotFoundError:
             self.db.record_prereq("Kernel doesn't support power management", "❌")
@@ -608,7 +651,8 @@ class PrerequisiteValidator(AmdTool):
                     )
         if show_warning:
             self.db.record_prereq(
-                "Timer based wakeup doesn't work properly for your ASIC/firmware, please manually wake the system",
+                "Timer based wakeup doesn't work properly for your "
+                "ASIC/firmware, please manually wake the system",
                 "🚦",
             )
         return True
@@ -631,7 +675,7 @@ class PrerequisiteValidator(AmdTool):
                 for line in contents.split("\n"):
                     if "WAKE_INT_MASTER_REG:" in line:
                         val = "en" if int(line.split()[1], 16) & BIT(15) else "dis"
-                        self.db.record_debug("Windows GPIO 0 debounce: %sabled" % val)
+                        self.db.record_debug(f"Windows GPIO 0 debounce: {val}abled")
                         continue
                     if not header and re.search("trigger", line):
                         debug_str += line + "\n"
@@ -671,7 +715,9 @@ class PrerequisiteValidator(AmdTool):
                         self.db.record_prereq(f"{interface} has WoL enabled", "✅")
                     else:
                         self.db.record_prereq(
-                            f"Platform may have low hardware sleep residency with Wake-on-lan disabled. Run `ethtool -s {interface} wol g` to enable it if necessary.",
+                            "Platform may have low hardware sleep residency "
+                            "with Wake-on-lan disabled. Run `ethtool -s "
+                            f"{interface} wol g` to enable it if necessary.",
                             "🚦",
                         )
         return True
@@ -726,7 +772,8 @@ class PrerequisiteValidator(AmdTool):
             # Dictionary of instance id to firmware version mappings that
             # have been "reported" to be problematic
             device_map = {
-                "8c36f7ee-cc11-4a36-b090-6363f54ecac2": "0.1.26",  # https://gitlab.freedesktop.org/drm/amd/-/issues/3443
+                # https://gitlab.freedesktop.org/drm/amd/-/issues/3443
+                "8c36f7ee-cc11-4a36-b090-6363f54ecac2": "0.1.26",
             }
             interesting_plugins = ["nvme", "tpm", "uefi_capsule"]
             if device.get_plugin() in interesting_plugins:
@@ -743,7 +790,8 @@ class PrerequisiteValidator(AmdTool):
                     item in device.get_guids() or item in device.get_instance_ids()
                 ) and ver in device.get_version():
                     self.db.record_prereq(
-                        f"Platform may have problems resuming.  Upgrade the firmware for '{device.get_name()}' if you have problems.",
+                        "Platform may have problems resuming.  Upgrade the "
+                        f"firmware for '{device.get_name()}' if you have problems.",
                         "🚦",
                     )
         return True
@@ -792,12 +840,13 @@ class PrerequisiteValidator(AmdTool):
             else:
                 acpi_hid = ""
             # set prefix if last device
-            prefix = "| " if dev != devices[-1] else "└─"
-            debug_str += "{prefix}{name} [{acpi_hid}] : {acpi_path}\n".format(
-                prefix=prefix, name=name, acpi_hid=acpi_hid, acpi_path=acpi_path
-            )
+            prefix = "│ " if dev != devices[-1] else "└─"
+            debug_str += f"{prefix}{name} [{acpi_hid}] : {acpi_path}\n"
             if "IDEA5002" in name:
-                remediation = f"echo {parent.sys_path.split('/')[-1]} | sudo tee /sys/bus/i2c/drivers/{parent.driver}/unbind"
+                remediation = (
+                    f"echo {parent.sys_path.split('/')[-1]} | "
+                    f"sudo tee /sys/bus/i2c/drivers/{parent.driver}/unbind"
+                )
 
                 self.db.record_prereq(f"{name} may cause spurious wakeups", "❌")
                 self.failures += [I2CHidBug(name, remediation)]
@@ -834,22 +883,13 @@ class PrerequisiteValidator(AmdTool):
             if os.path.exists(p):
                 acpi = read_file(p)
                 debug_str += (
-                    "{prefix}{pci_slot_name} : {vendor} {cls} [{id}] : {acpi}\n".format(
-                        prefix=prefix,
-                        pci_slot_name=pci_slot_name,
-                        vendor=database_vendor,
-                        cls=database_class,
-                        id=pci_id,
-                        acpi=acpi,
-                    )
+                    f"{prefix}{pci_slot_name} : "
+                    f"{database_vendor} {database_class} [{pci_id}] : {acpi}\n"
                 )
             else:
-                debug_str += "{prefix}{pci_slot_name} : {vendor} {cls} [{id}]\n".format(
-                    prefix=prefix,
-                    vendor=database_vendor,
-                    pci_slot_name=pci_slot_name,
-                    cls=database_class,
-                    id=pci_id,
+                debug_str += (
+                    f"{prefix}{pci_slot_name} : "
+                    f"{database_vendor} {database_class} [{pci_id}]\n"
                 )
         if debug_str:
             self.db.record_debug(debug_str)
@@ -908,7 +948,7 @@ class PrerequisiteValidator(AmdTool):
                         stdout=subprocess.DEVNULL,
                         stderr=subprocess.DEVNULL,
                     )
-                    self.db.record_debug_file("%s.dsl" % prefix)
+                    self.db.record_debug_file(f"{prefix}.dsl")
                 except subprocess.CalledProcessError as e:
                     self.db.record_prereq(
                         f"Failed to capture ACPI table: {e.output}", "👀"
@@ -925,10 +965,10 @@ class PrerequisiteValidator(AmdTool):
             self.db.record_prereq(desc, "🔋")
 
     def capture_logind(self):
+        """Capture logind.conf settings"""
         base = os.path.join("/", "etc", "systemd", "logind.conf")
         if not os.path.exists(base):
             return True
-        import configparser
 
         config = configparser.ConfigParser()
         config.read(base)
@@ -982,7 +1022,8 @@ class PrerequisiteValidator(AmdTool):
             _, cpu_count, _, _ = read_cpuid(0, 0x80000026, 1)
             if cpu_count > max_cpus:
                 self.db.record_prereq(
-                    f"The kernel has been limited to {max_cpus} CPU cores, but the system has {cpu_count} cores",
+                    f"The kernel has been limited to {max_cpus} CPU cores, "
+                    f"but the system has {cpu_count} cores",
                     "❌",
                 )
                 self.failures += [LimitedCores(cpu_count, max_cpus)]
@@ -996,12 +1037,6 @@ class PrerequisiteValidator(AmdTool):
         except PermissionError:
             self.db.record_prereq("CPUID checks unavailable", "🚦")
 
-        if valid:
-            self.db.record_prereq(
-                f"{self.cpu_model_string} (family {self.cpu_family:x} model {self.cpu_model:x})",
-                "✅",
-            )
-
         return True
 
     def check_msr(self):
@@ -1020,7 +1055,7 @@ class PrerequisiteValidator(AmdTool):
                 if not check_bits(val, expect_val):
                     self.failures += [MSRFailure()]
                     return False
-                self.db.record_prereq("PC6 and CC6 enabled", "✅")
+            self.db.record_prereq("PC6 and CC6 enabled", "✅")
         except FileNotFoundError:
             self.db.record_prereq(
                 "Unable to check MSRs: MSR kernel module not loaded", "❌"
@@ -1111,7 +1146,9 @@ class PrerequisiteValidator(AmdTool):
         if "pcie_port_pm=off" in cmdline:
             return True
         self.db.record_prereq(
-            "Platform may hang resuming.  Upgrade your firmware or add pcie_port_pm=off to kernel command line if you have problems.",
+            "Platform may hang resuming.  "
+            "Upgrade your firmware or add pcie_port_pm=off to kernel command "
+            "line if you have problems.",
             "🚦",
         )
         return False
@@ -1139,6 +1176,7 @@ class PrerequisiteValidator(AmdTool):
             self.capture_linux_firmware,
             self.capture_logind,
             self.capture_pci_acpi,
+            self.capture_edid,
         ]
         checks = []
 

amd_debug/s2idle.py

@@ -8,7 +8,14 @@ import subprocess
 import sqlite3
 
 from datetime import date, timedelta, datetime
-from amd_debug.common import is_root, relaunch_sudo, show_log_info, version, running_ssh
+from amd_debug.common import (
+    colorize_choices,
+    is_root,
+    relaunch_sudo,
+    show_log_info,
+    version,
+    running_ssh,
+)
 
 from amd_debug.validator import SleepValidator
 from amd_debug.installer import Installer
@@ -51,12 +58,14 @@ def display_report_file(fname, fmt) -> None:
         return
     user = os.environ.get("SUDO_USER")
     if user:
-        # ensure that xdg tools will know how to display the file (user may need to call tool with sudo -E)
+        # ensure that xdg tools will know how to display the file
+        # (user may need to call tool with sudo -E)
         if os.environ.get("XDG_SESSION_TYPE"):
             subprocess.call(["sudo", "-E", "-u", user, "xdg-open", fname])
         else:
             print(
-                f"To display report automatically in browser launch tool with '-E' argument (Example: sudo -E {sys.argv[0]})"
+                "To display report automatically in browser launch tool "
+                f"with '-E' argument (Example: sudo -E {sys.argv[0]})"
             )
 
 
@@ -98,7 +107,9 @@ def prompt_report_arguments(since, until, fname, fmt) -> str:
         sys.exit(f"Invalid date, use YYYY-MM-DD: {e}")
 
     if not fmt:
-        fmt = input(f"{Headers.FormatDescription} (default {get_report_format()})? ")
+        fmt = input(
+            f"{Headers.FormatDescription} ({colorize_choices(Defaults.format_choices, get_report_format())})? "
+        )
         if not fmt:
             fmt = get_report_format()
         if fmt not in Defaults.format_choices:
@@ -176,12 +187,12 @@ def report(since, until, fname, fmt, tool_debug, report_debug) -> bool:
     return True
 
 
-def test(
+def run_test_cycle(
     duration, wait, count, fmt, fname, force, debug, rand, logind, bios_debug
 ) -> bool:
     """Run a test"""
     app = Installer(tool_debug=debug)
-    app.set_requirements("iasl", "ethtool")
+    app.set_requirements("iasl", "ethtool", "edid-decode")
     if not app.install_dependencies():
         print("Failed to install dependencies")
         return False
@@ -232,7 +243,7 @@ def test(
 def install(debug) -> None:
     """Install the tool"""
     installer = Installer(tool_debug=debug)
-    installer.set_requirements("iasl", "ethtool")
+    installer.set_requirements("iasl", "ethtool", "edid-decode")
     if not installer.install_dependencies():
         sys.exit("Failed to install dependencies")
     try:
@@ -259,7 +270,8 @@ def parse_args():
     """Parse command line arguments"""
     parser = argparse.ArgumentParser(
         description="Swiss army knife for analyzing Linux s2idle problems",
-        epilog="The tool can run an immediate test with the 'test' command or can be used to hook into systemd for building reports later.\n"
+        epilog="The tool can run an immediate test with the 'test' command "
+        "or can be used to hook into systemd for building reports later.\n"
         "All optional arguments will be prompted if needed.\n"
         "To use non-interactively, please populate all optional arguments.",
     )
@@ -282,7 +294,10 @@ def parse_args():
     test_cmd.add_argument(
         "--random",
         action="store_true",
-        help="Run sleep cycles for random durations and wait, using the --duration and --wait arguments as an upper bound",
+        help=(
+            "Run sleep cycles for random durations and wait, using the "
+            "--duration and --wait arguments as an upper bound",
+        ),
     )
     test_cmd.add_argument(
         "--force",
@@ -385,7 +400,7 @@ def main():
         )
     elif args.action == "test":
         relaunch_sudo()
-        ret = test(
+        ret = run_test_cycle(
             args.duration,
             args.wait,
             args.count,

{amd_debug_tools-0.2.0.dist-info → amd_debug_tools-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.0
+Version: 0.2.1
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT

amd_debug_tools-0.2.1.dist-info/RECORD

@@ -0,0 +1,45 @@
+launcher.py,sha256=_Gs0W8tUB2wkTy5Nz4qEzG0VqQcnO7xuIQj0GwV_KbY,968
+test_acpi.py,sha256=wtS43Rz95h7YEEJBeFa6Mswaeo4syBZrw4hY8i0YbJY,3117
+test_batteries.py,sha256=nN5pfP5El7Whypq3HHEpW8bufdf5EWSTVGbayfNQYP4,3360
+test_bios.py,sha256=GBAXE_rXd2G-JE0XJ8AvYcF9Me6LTyQQQ8h0Ib3cpxQ,8981
+test_common.py,sha256=VBPRNLt3y-oSVXC-1HGbZF7jHA_6msW-9MMmbMjNrew,11713
+test_database.py,sha256=q5ZjI5u20f7ki6iCY5o1iPi0YOvPz1_W0LTDraU8mN4,10040
+test_display.py,sha256=hHggv-zBthF1BlwWWSjzAm7BBw1DWcElwil5xAuz87g,5822
+test_failures.py,sha256=H1UxXeVjhJs9-j9yas4vwAha676GX1Es7Kz8RN2B590,6845
+test_installer.py,sha256=LqTAjcRIc7DkdHBYBMsRsbDeVtIh_2oEVhETCb_B0cY,10183
+test_kernel.py,sha256=RW-eLbae02Bhwfu1cegqA1pTj6AS5IqD5lLe-6T0Rjo,7871
+test_launcher.py,sha256=govYHL0Cpj9d5msteV5SfR7Covft31rJuzRkDeytHcY,1461
+test_prerequisites.py,sha256=owO-tMgq_3W4Rm85TgdOFGOabKk9OrUUbRHXD0NHiPg,77018
+test_pstate.py,sha256=a9oAJ9-LANX32XNQhplz6Y75VNYc__QqoSBKIrwvANg,6058
+test_s2idle.py,sha256=VT5iNNVxaL6JdupYPHTIsIVWLBgHRHGTPyXFMO_k1w0,31312
+test_sleep_report.py,sha256=R3cUPPT9r9q4q93xk6NFvi4ySgT5laqidk2SASuTWIo,5878
+test_validator.py,sha256=0dwpWFMHHG16vYo6ON_bUa5Av2NTVEJML93oAZZgcH8,30505
+test_wake.py,sha256=6zi5GVFHQKU1sTWw3O5-aGriB9uu5713QLn4l2wjhpM,7152
+amd_debug/__init__.py,sha256=aOtpIEKGLUStrh0e4qgilHW7HgF4Od-r9pOoZ87NwAM,1105
+amd_debug/acpi.py,sha256=fkD3Sov8cRT5ryPlakRlT7Z9jiCLT9x_MPWxt3xU_tc,3161
+amd_debug/battery.py,sha256=WN-6ys9PHCZIwg7PdwyBOa62GjBp8WKG0v1YZt5_W5s,3122
+amd_debug/bios.py,sha256=wmPKDsTZeQqsHjWpv-YHdgRNlCtFdzHQ6jJf0H3hjN8,3971
+amd_debug/common.py,sha256=QP3UnOrMFO7NGBgi2CGUvBmtYIalm_Z9xxlvcpze_uQ,9613
+amd_debug/database.py,sha256=GkRg3cmaNceyQ2_hy0MBAlMbnTDPHo2co2o4ObWpnQg,10621
+amd_debug/display.py,sha256=5L9x9tI_UoulHpIvuxuVASRtdXta7UCW_JjTb5StEB0,953
+amd_debug/failures.py,sha256=QV3wxl9NYxUV5e0VmMy-pNLg4PoLeCVy0RvBux1pnZM,22536
+amd_debug/installer.py,sha256=2upWqR3e9flu-KruDXkoqCu-P4e3R7aVpMQ6dRRurTU,13064
+amd_debug/kernel.py,sha256=xzAy-sDY5-sd4jxyU7EaBokS7YsvEjoWRuexaTJNRBc,11851
+amd_debug/prerequisites.py,sha256=szi1YT-iY4F3EoG7gRcN9kVTV4XsjDDMTjLfN7vkhJ4,47685
+amd_debug/pstate.py,sha256=akGdJkIxBp0bx3AeGv6ictNxwv8m0j9vQ2IZB0Jx3dM,9518
+amd_debug/s2idle-hook,sha256=LLiaqPtGd0qetu9n6EYxKHZaIdHpVQDONdOuSc0pfFg,1695
+amd_debug/s2idle.py,sha256=QAQ1EIhD823_dBsAmSqZuuGTF--bIz2CK2xA13PgJ8c,12695
+amd_debug/sleep_report.py,sha256=dRoE21nkPMFoa5L9i5XrzPug4KesLfAf1RpPFB7Xpt0,15555
+amd_debug/validator.py,sha256=VomxJOp6ZYBp3oYEaNsD-rvio_b346VSRz7-hyhCS_c,33234
+amd_debug/wake.py,sha256=xT8WrFrN6voCmXWo5dsn4mQ7iR2QJxHrrYBd3EREG-Q,3936
+amd_debug/bash/amd-s2idle,sha256=g_cle1ElCJpwE4wcLezL6y-BdasDKTnNMhrtzKLE9ks,1142
+amd_debug/templates/html,sha256=tnpqHDZF5FfhC6YNRUfOG6Vn9ZtISFr10kEXSB476Mw,14518
+amd_debug/templates/md,sha256=F0xt7m-lOsSz1VeucHA6a-1gsOH7rrik15biXnDgd54,904
+amd_debug/templates/stdout,sha256=hyoOJ96K2dJfnWRWhyCuariLKbEHXvs9mstV_g5aMdI,469
+amd_debug/templates/txt,sha256=nNdsvbPFOhGdL7VA-_4k5aN3nB-6ouGQt6AsWst7T3w,649
+amd_debug_tools-0.2.1.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.1.dist-info/METADATA,sha256=mNzq0JUgGUeSwdF_H6BRgFb_dNFMvKgu-Htu381x0tE,6783
+amd_debug_tools-0.2.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+amd_debug_tools-0.2.1.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
+amd_debug_tools-0.2.1.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.1.dist-info/RECORD,,

{amd_debug_tools-0.2.0.dist-info → amd_debug_tools-0.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

amd_debug_tools-0.2.1.dist-info/top_level.txt

@@ -0,0 +1,18 @@
+amd_debug
+launcher
+test_acpi
+test_batteries
+test_bios
+test_common
+test_database
+test_display
+test_failures
+test_installer
+test_kernel
+test_launcher
+test_prerequisites
+test_pstate
+test_s2idle
+test_sleep_report
+test_validator
+test_wake