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

amd_debug/sleep_report.py

@@ -5,6 +5,7 @@ import os
 import re
 import math
 from datetime import datetime, timedelta
+import numpy as np
 from tabulate import tabulate
 from jinja2 import Environment, FileSystemLoader
 import pandas as pd
@@ -73,6 +74,8 @@ def format_percent(val):
 
 def format_timedelta(val):
     """Format seconds as a nicer format"""
+    if math.isnan(val):
+        val = 0
     return str(timedelta(seconds=val))
 
 
@@ -97,8 +100,23 @@ class SleepReport(AmdTool):
         self.debug = report_debug
         self.format = fmt
         self.failures = []
-        self.df = self.db.report_summary_dataframe(self.since, self.until)
-        self.pre_process_dataframe()
+        if since and until:
+            self.df = self.db.report_summary_dataframe(self.since, self.until)
+            self.pre_process_dataframe()
+        else:
+            self.df = pd.DataFrame(
+                columns=[
+                    "t0",
+                    "t1",
+                    "requested",
+                    "hw",
+                    "b0",
+                    "b1",
+                    "full",
+                    "wake_irq",
+                    "gpio",
+                ]
+            )
         self.battery_svg = None
         self.hwsleep_svg = None
 
@@ -136,6 +154,7 @@ class SleepReport(AmdTool):
         self.df["Duration"] = self.df["t1"].apply(format_as_seconds) - self.df[
             "t0"
         ].apply(format_as_seconds)
+        self.df["Duration"] = self.df["Duration"].replace(0, np.nan)
         self.df["Hardware Sleep"] = (self.df["hw"] / self.df["Duration"]).apply(
             parse_hw_sleep
         )
@@ -187,7 +206,8 @@ class SleepReport(AmdTool):
                 format_watts
             )
 
-    def convert_gpio_dataframe(self, content):
+    def convert_table_dataframe(self, content):
+        """Convert a table like dataframe to an HTML table"""
         header = False
         rows = []
         for line in content.split("\n"):
@@ -196,17 +216,25 @@ class SleepReport(AmdTool):
                 if header:
                     continue
                 header = True
+            line = line.strip("│")
+            line = line.replace("├─", "└─")
             if "|" in line:
                 # first column missing '|'
                 rows.append(line.replace("\t", "|"))
         columns = [row.split("|") for row in rows]
         df = pd.DataFrame(columns[1:], columns=columns[0])
-        return df.to_html(index=False, table_id="gpio")
+        return df.to_html(index=False, justify="center", col_space=30)
 
     def get_prereq_data(self):
         """Get the prereq data"""
         prereq = []
         prereq_debug = []
+        tables = [
+            "int|active",
+            "ACPI name",
+            "PCI Slot",
+            "DMI|value",
+        ]
         ts = self.db.get_last_prereq_ts()
         if not ts:
             return [], "", []
@@ -216,23 +244,24 @@ class SleepReport(AmdTool):
         if self.debug:
             for row in self.db.report_debug(t0):
                 content = row[0]
-                if self.format == "html" and "int|active" in content:
-                    content = self.convert_gpio_dataframe(content)
-                prereq_debug.append(
-                    {"data": "{message}".format(message=content.strip())}
-                )
+                if self.format == "html" and [
+                    table for table in tables if table in content
+                ]:
+                    content = self.convert_table_dataframe(content)
+                prereq_debug.append({"data": f"{content.strip()}"})
         return prereq, t0, prereq_debug
 
     def get_cycle_data(self):
         """Get the cycle data"""
         cycles = []
         debug = []
+        tables = ["Wakeup Source"]
         num = 0
         for cycle in self.df["Start Time"]:
             if self.format == "html":
                 data = ""
                 for line in self.db.report_cycle_data(cycle).split("\n"):
-                    data += "<p>{line}</p>".format(line=line)
+                    data += f"<p>{line}</p>"
                 cycles.append({"cycle_num": num, "data": data})
             else:
                 cycles.append([num, self.db.report_cycle_data(cycle)])
@@ -240,7 +269,12 @@ class SleepReport(AmdTool):
                 messages = []
                 priorities = []
                 for row in self.db.report_debug(cycle):
-                    messages.append(row[0])
+                    content = row[0]
+                    if self.format == "html" and [
+                        table for table in tables if table in content
+                    ]:
+                        content = self.convert_table_dataframe(content)
+                    messages.append(content)
                     priorities.append(get_log_priority(row[1]))
                 debug.append(
                     {"cycle_num": num, "messages": messages, "priorities": priorities}
@@ -265,58 +299,69 @@ class SleepReport(AmdTool):
             prereq, prereq_date, prereq_debug = self.get_prereq_data()
 
         # Load the cycle and/or debug data
-        cycles, debug = self.get_cycle_data()
-
-        self.post_process_dataframe()
-        failures = None
-        if self.format == "md":
-            summary = self.df.to_markdown(floatfmt=".02f")
-            cycle_data = tabulate(cycles, headers=["Cycle", "data"], tablefmt="pipe")
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="pipe",
+        if not self.df.empty:
+            cycles, debug = self.get_cycle_data()
+
+            self.post_process_dataframe()
+            failures = None
+            if self.format == "md":
+                summary = self.df.to_markdown(floatfmt=".02f")
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="pipe"
                 )
-        elif self.format == "txt":
-            summary = tabulate(self.df, headers=self.df.columns, tablefmt="fancy_grid")
-            cycle_data = tabulate(
-                cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
-            )
-            if self.failures:
-                failures = tabulate(
-                    self.failures,
-                    headers=["Cycle", "Problem", "Explanation"],
-                    tablefmt="fancy_grid",
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="pipe",
+                    )
+            elif self.format == "txt":
+                summary = tabulate(
+                    self.df, headers=self.df.columns, tablefmt="fancy_grid"
+                )
+                cycle_data = tabulate(
+                    cycles, headers=["Cycle", "data"], tablefmt="fancy_grid"
                 )
-        elif self.format == "html":
-            summary = ""
-            row = 0
-            # we will use javascript to highlight the high values
-            for line in self.df.to_html(table_id="summary", render_links=True).split(
-                "\n"
-            ):
-                if "<tr>" in line:
-                    line = line.replace(
-                        "<tr>",
-                        '<tr class="row-low" onclick="pick_summary_cycle(%d)">' % row,
+                if self.failures:
+                    failures = tabulate(
+                        self.failures,
+                        headers=["Cycle", "Problem", "Explanation"],
+                        tablefmt="fancy_grid",
                     )
-                    row = row + 1
-                summary += line
-            cycle_data = cycles
-            failures = self.failures
-        # only show one cycle in stdout output even if we found more
-        else:
-            df = self.df.tail(1)
-            summary = tabulate(
-                df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
-            )
-            if cycles[-1][0] == df.index.start:
-                cycle_data = cycles[-1][-1]
+            elif self.format == "html":
+                summary = ""
+                row = 0
+                # we will use javascript to highlight the high values
+                for line in self.df.to_html(
+                    table_id="summary", render_links=True
+                ).split("\n"):
+                    if "<tr>" in line:
+                        line = line.replace(
+                            "<tr>",
+                            f'<tr class="row-low" onclick="pick_summary_cycle({row})">',
+                        )
+                        row = row + 1
+                    summary += line
+                cycle_data = cycles
+                failures = self.failures
+            # only show one cycle in stdout output even if we found more
             else:
-                cycle_data = None
-            if self.failures and self.failures[-1][0] == df.index.start:
-                failures = self.failures[-1][-1]
+                df = self.df.tail(1)
+                summary = tabulate(
+                    df, headers=self.df.columns, tablefmt="fancy_grid", showindex=False
+                )
+                if cycles[-1][0] == df.index.start:
+                    cycle_data = cycles[-1][-1]
+                else:
+                    cycle_data = None
+                if self.failures and self.failures[-1][0] == df.index.start:
+                    failures = self.failures[-1][-1]
+        else:
+            cycles = []
+            debug = []
+            cycle_data = []
+            summary = "No sleep cycles found in the database."
+            failures = None
 
         # let it burn
         context = {
@@ -333,7 +378,7 @@ class SleepReport(AmdTool):
             "failures": failures,
         }
         if self.fname:
-            with open(self.fname, "w") as f:
+            with open(self.fname, "w", encoding="utf-8") as f:
                 f.write(template.render(context))
             if "SUDO_UID" in os.environ:
                 os.chown(
@@ -345,30 +390,30 @@ class SleepReport(AmdTool):
 
     def build_battery_chart(self):
         """Build a battery chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         if "Battery Ave Rate" not in self.df.columns:
             return
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Battery Ave Rate"], color="green", label="Charge/Discharge Rate"
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Battery Delta"],
             color="grey",
             label="Battery Change",
             alpha=0.3,
         )
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Rate (Watts)")
         ax2.set_ylabel("Battery Change (%)")
@@ -385,20 +430,20 @@ class SleepReport(AmdTool):
 
     def build_hw_sleep_chart(self):
         """Build the hardware sleep chart using matplotlib and seaborn"""
-        import matplotlib.pyplot as plt
-        import seaborn as sns
-        import io
+        import matplotlib.pyplot as plt  # pylint: disable=import-outside-toplevel
+        import seaborn as sns  # pylint: disable=import-outside-toplevel
+        import io  # pylint: disable=import-outside-toplevel
 
         plt.set_loglevel("warning")
-        fig, ax1 = plt.subplots()
-        lns3 = ax1.plot(
+        _fig, ax1 = plt.subplots()
+        ax1.plot(
             self.df["Hardware Sleep"],
             color="red",
             label="Hardware Sleep",
         )
 
         ax2 = ax1.twinx()
-        lns1 = sns.barplot(
+        sns.barplot(
             x=self.df.index,
             y=self.df["Duration"] / 60,
             color="grey",
@@ -406,9 +451,9 @@ class SleepReport(AmdTool):
             alpha=0.3,
         )
 
-        max = int(len(self.df.index) / 10)
-        if max:
-            ax1.set_xticks(range(0, len(self.df.index), max))
+        max_range = int(len(self.df.index) / 10)
+        if max_range:
+            ax1.set_xticks(range(0, len(self.df.index), max_range))
         ax1.set_xlabel("Cycle")
         ax1.set_ylabel("Percent")
         ax2.set_yscale("log")
@@ -427,15 +472,13 @@ class SleepReport(AmdTool):
     def run(self, inc_prereq=True):
         """Run the report"""
 
-        if self.df.empty:
-            raise ValueError(f"No data found between {self.since} and {self.until}")
-
         characters = print_temporary_message("Building report, please wait...")
 
-        # Build charts in the page for html and markdown formats
-        if len(self.df.index) > 1 and (self.format == "html" or self.format == "md"):
-            self.build_battery_chart()
-            self.build_hw_sleep_chart()
+        if not self.df.empty:
+            # Build charts in the page for html format
+            if len(self.df.index) > 1 and self.format == "html":
+                self.build_battery_chart()
+                self.build_hw_sleep_chart()
 
         # Render the template using jinja
         msg = self.build_template(inc_prereq)

amd_debug/templates/html

@@ -42,12 +42,14 @@
         table,
         th,
         td {
-            border-width: 0;
+            border-width: 1;
+            border-collapse: collapse;
             table-layout: fixed;
             font-family: sans-serif;
             letter-spacing: 0.02em;
             color: #000000;
-            margin-bottom: 10px;
+            text-align: left;
+            padding: 3px;
         }
 
         .○ {

amd_debug/templates/md

@@ -28,12 +28,5 @@ Measured {{ prereq_date }}.
 ## Summary
 {{ summary }}
 
-{% if battery_svg %}
-{{ battery_svg | safe }}
-{% endif %}
-{% if hwsleep_svg %}
-{{ hwsleep_svg | safe }}
-{% endif %}
-
 ## Failures reported
 {{ failures }}

amd_debug/validator.py

@@ -290,13 +290,12 @@ class SleepValidator(AmdTool):
                 sys_name = pnp.sys_name
 
             name = name.replace('"', "")
-            devices.append(f"{name} [{sys_name}]: {wake_en}")
+            devices.append(f"{name}|{sys_name}|{wake_en}")
         devices.sort()
-        self.db.record_debug("Possible wakeup sources:")
+        debug_str = "Wakeup Source|Linux Device|Status\n"
         for dev in devices:
-            # set prefix if last device
-            prefix = "│ " if dev != devices[-1] else "└─"
-            self.db.record_debug(f"{prefix}{dev}")
+            debug_str += f"{dev}\n"
+        self.db.record_debug(debug_str)
 
     def capture_lid(self) -> None:
         """Capture lid state"""
@@ -469,12 +468,10 @@ class SleepValidator(AmdTool):
                     )
                 return False
             except FileNotFoundError:
-                self.db.record_cycle_data("HW sleep statistics file missing", "❌")
-                return False
+                self.db.record_debug(f"HW sleep statistics file {p} is missing")
         if not self.hw_sleep_duration:
             self.db.record_cycle_data("Did not reach hardware sleep state", "❌")
-
-        return self.hw_sleep_duration is not None
+        return self.hw_sleep_duration
 
     def capture_command_line(self):
         """Capture the kernel command line to debug"""
@@ -674,7 +671,7 @@ class SleepValidator(AmdTool):
     def prep(self):
         """Prepare the system for suspend testing"""
         self.last_suspend = datetime.now()
-        self.kernel_log.seek_tail()
+        self.kernel_log.seek_tail(self.last_suspend)
         self.db.start_cycle(self.last_suspend)
         self.kernel_duration = 0
         self.hw_sleep_duration = 0
@@ -749,16 +746,18 @@ class SleepValidator(AmdTool):
                 return False
         else:
             old = get_wakeup_count()
+            p = os.path.join("/", "sys", "power", "state")
+            fd = os.open(p, os.O_WRONLY | os.O_SYNC)
             try:
-                p = os.path.join("/", "sys", "power", "state")
-                with open(p, "w", encoding="utf-8") as w:
-                    w.write("mem")
+                os.write(fd, b"mem")
             except OSError as e:
                 new = get_wakeup_count()
                 self.db.record_cycle_data(
                     f"Failed to set suspend state ({old} -> {new}): {e}", "❌"
                 )
                 return False
+            finally:
+                os.close(fd)
             return True
 
     def unlock_session(self):
@@ -782,6 +781,7 @@ class SleepValidator(AmdTool):
 
     def run(self, duration, count, wait, rand, logind):
         """Run the suspend test"""
+        min_duration = 4
         if not count:
             return True
 
@@ -789,8 +789,13 @@ class SleepValidator(AmdTool):
             self.logind = True
 
         if rand:
+            if duration <= min_duration:
+                print_color(f"Invalid max duration {duration}", "❌")
+                self.db.sync()
+                self.report_cycle()
+                return False
             print_color(
-                f"Running {count} cycle random test with max duration of {duration}s and a max wait of {wait}s",
+                f"Running {count} cycle random test with min duration of {min_duration}s, max duration of {duration}s and a max wait of {wait}s",
                 "🗣️",
             )
         elif count > 1:
@@ -801,7 +806,7 @@ class SleepValidator(AmdTool):
             )
         for i in range(1, count + 1):
             if rand:
-                self.requested_duration = random.randint(1, duration)
+                self.requested_duration = random.randint(min_duration, duration)
                 requested_wait = random.randint(1, wait)
             else:
                 self.requested_duration = duration

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: amd-debug-tools
-Version: 0.2.1
+Version: 0.2.3
 Summary: debug tools for AMD systems
 Author-email: Mario Limonciello <superm1@kernel.org>
 License-Expression: MIT
@@ -125,8 +125,9 @@ The following optional arguments are supported for this command:
         --format FORMAT       Format of the report to produce (html, txt or md)
         --report-file         File to write the report to
         --tool-debug          Enable tool debug logging
-        --report-debug        Include debug messages in the report
-
+        --report-debug
+        --no-report-debug
+                              Include debug messages in report (WARNING: can significantly increase report size)
 If the tool is launched with an environment that can call `xdg-open`, the report
 will be opened in a browser.
 

{amd_debug_tools-0.2.1.dist-info → amd_debug_tools-0.2.3.dist-info}/RECORD

@@ -2,44 +2,44 @@ 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_common.py,sha256=fb16Oilh5ga6VgF-UgBj6azoYzZnPrS7KpECQ3nCwlg,16335
 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_installer.py,sha256=oDMCvaKqqAWjTggltacnasQ-s1gyUvXPDcNrCUGnux4,10216
 test_kernel.py,sha256=RW-eLbae02Bhwfu1cegqA1pTj6AS5IqD5lLe-6T0Rjo,7871
 test_launcher.py,sha256=govYHL0Cpj9d5msteV5SfR7Covft31rJuzRkDeytHcY,1461
-test_prerequisites.py,sha256=owO-tMgq_3W4Rm85TgdOFGOabKk9OrUUbRHXD0NHiPg,77018
+test_prerequisites.py,sha256=VXN822W-7ZZHXZkJYH5MeKsDVBC-ttUZggYlcoPjVyM,83335
 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_s2idle.py,sha256=6NaqGp9VOLr_Tr3KczSvfSo3M882aYEbSvRV9xvUMcA,33534
+test_sleep_report.py,sha256=ANuxYi_C1oSKAi4xUU2wBu4SwJtcZA7VPpazBe3_WUQ,6922
+test_validator.py,sha256=-MfrWfhwef_aRqOSD_dJGhH0shsghhtOBgzeijzyLW4,33975
 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/common.py,sha256=H9tIRlRFOMwe0d3f2-vXQeK2rJl5Z1WJzkpQM9ivpOc,10347
 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/failures.py,sha256=z4O4Q-akv3xYGssSZFCqE0cDE4P9F_aw1hxil3McoD4,22910
+amd_debug/installer.py,sha256=r6r_nVWv8qYdrqAvnAzQhRiS5unBDOkXsqUfHvFK8uM,14249
+amd_debug/kernel.py,sha256=UAlxlXNuZxtHVtrfCmTp12YombVaUs4mizOxwuXTX2M,12038
+amd_debug/prerequisites.py,sha256=r4_IFTL-1YcPptlt6Nump7iscRx1bBCGF33hqNQB0X0,49867
 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/s2idle.py,sha256=Ei5ONnJyHz9aQbstRZYnofhJ_sJOAOZQxLgIuWfvcng,13218
+amd_debug/sleep_report.py,sha256=hhqu711AKtjeYF2xmGcejyCyyPtmq4-gC_hROUCrC0g,17317
+amd_debug/validator.py,sha256=nZ5UpvvsABw4yTea_pZ8DHaLbSoM5VHz3uvlrdWAb34,33444
 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/html,sha256=JfGhpmHIB2C2GItdGI1kuC8uayqEVgrpQvAWAj35eZ4,14580
+amd_debug/templates/md,sha256=r8X2aehnH2gzj0WHYTZ5K9wAqC5y39i_3nkDORSC0uM,787
 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.3.dist-info/licenses/LICENSE,sha256=RBlZI6r3MRGzymI2VDX2iW__D2APDbMhu_Xg5t6BWeo,1066
+amd_debug_tools-0.2.3.dist-info/METADATA,sha256=-DdxkPvWEXMifkgAjfyNIpleo_rHFPIH8nS6v3AWJTk,6877
+amd_debug_tools-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+amd_debug_tools-0.2.3.dist-info/entry_points.txt,sha256=HC11T2up0pPfroAn6Pg5M2jOZXhkWIipToJ1YPTKqu8,116
+amd_debug_tools-0.2.3.dist-info/top_level.txt,sha256=XYjxExbUTEtiIlag_5iQvZSVOC1EIxhKM4NLklReQ0k,234
+amd_debug_tools-0.2.3.dist-info/RECORD,,

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

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