amd-debug-tools 0.2.5__py3-none-any.whl → 0.2.12__py3-none-any.whl

test_s2idle.py

@@ -117,9 +117,9 @@ class TestParseArgs(unittest.TestCase):
 
     def test_version_command(self):
         """Test parse_args with version command"""
-        sys.argv = ["s2idle.py", "version"]
+        sys.argv = ["s2idle.py", "--version"]
         args = parse_args()
-        self.assertEqual(args.action, "version")
+        self.assertTrue(args.version)
 
 
 class TestMainFunction(unittest.TestCase):
@@ -214,7 +214,7 @@ class TestMainFunction(unittest.TestCase):
         """Test main function with version action"""
         sys.argv = ["s2idle.py", "version"]
         with patch("amd_debug.s2idle.parse_args") as mock_parse_args:
-            mock_parse_args.return_value = argparse.Namespace(action="version")
+            mock_parse_args.return_value = argparse.Namespace(version=True, action=None)
             mock_version.return_value = "1.0.0"
             with patch("builtins.print") as mock_print:
                 result = main()
@@ -226,7 +226,9 @@ class TestMainFunction(unittest.TestCase):
         """Test main function with no action specified"""
         sys.argv = ["s2idle.py"]
         with patch("amd_debug.s2idle.parse_args") as mock_parse_args:
-            mock_parse_args.return_value = argparse.Namespace(action=None)
+            mock_parse_args.return_value = argparse.Namespace(
+                version=False, action=None
+            )
             with self.assertRaises(SystemExit) as cm:
                 main()
             self.assertEqual(cm.exception.code, "no action specified")
@@ -358,8 +360,10 @@ class TestTestFunction(unittest.TestCase):
     @patch("amd_debug.s2idle.prompt_test_arguments")
     @patch("amd_debug.s2idle.prompt_report_arguments")
     @patch("amd_debug.s2idle.display_report_file")
+    @patch("amd_debug.s2idle.datetime")
     def test_test_success(
         self,
+        mock_datetime,
         mock_display_report_file,
         mock_prompt_report_arguments,
         mock_prompt_test_arguments,
@@ -369,6 +373,11 @@ class TestTestFunction(unittest.TestCase):
         mock_installer,
     ):
         """Test the test function when everything succeeds"""
+        from datetime import datetime
+
+        mock_datetime.now.return_value = datetime(2023, 2, 1, 0, 0, 0)
+        mock_datetime.side_effect = lambda *args, **kwargs: datetime(*args, **kwargs)
+
         mock_installer_instance = mock_installer.return_value
         mock_installer_instance.install_dependencies.return_value = True
 
@@ -414,9 +423,11 @@ class TestTestFunction(unittest.TestCase):
         mock_sleep_validator_instance.run.assert_called_once_with(
             duration=10, wait=5, count=3, rand=False, logind=False
         )
+        from datetime import datetime
+
         mock_sleep_report.assert_called_once_with(
             since="2023-01-01",
-            until="2023-02-01",
+            until=datetime(2023, 2, 1, 0, 0, 0),
             fname="report.html",
             fmt="html",
             tool_debug=True,
@@ -600,12 +611,18 @@ class TestDisplayReportFile(unittest.TestCase):
         self, mock_subprocess_call, mock_env_get, mock_is_root
     ):
         """Test display_report_file when format is html, user is root, and SUDO_USER is set"""
-        display_report_file("report.html", "html")
+        with self.assertRaises(SystemExit):
+            display_report_file("/tmp/report.html", "html")
         mock_is_root.assert_called_once()
         mock_env_get.assert_any_call("SUDO_USER")
-        mock_env_get.assert_any_call("XDG_SESSION_TYPE")
         mock_subprocess_call.assert_called_once_with(
-            ["sudo", "-E", "-u", "testuser", "xdg-open", "report.html"]
+            [
+                "systemd-run",
+                "--user",
+                "--machine=testuser@.host",
+                "xdg-open",
+                "/tmp/report.html",
+            ]
         )
 
     @patch("amd_debug.s2idle.is_root", return_value=True)

test_ttm.py

@@ -0,0 +1,276 @@
+#!/usr/bin/python3
+# SPDX-License-Identifier: MIT
+
+"""
+This module contains unit tests for the ttm tool in the amd-debug-tools package.
+"""
+import unittest
+import sys
+import logging
+from unittest import mock
+
+from amd_debug.ttm import main, parse_args, AmdTtmTool, maybe_reboot
+
+
+class TestParseArgs(unittest.TestCase):
+    """Test parse_args function"""
+
+    @classmethod
+    def setUpClass(cls):
+        logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
+
+    def setUp(self):
+        self.default_sys_argv = sys.argv
+
+    def tearDown(self):
+        sys.argv = self.default_sys_argv
+
+    @mock.patch.object(sys, "argv", new=["ttm", "--version"])
+    def test_parse_args_version(self):
+        """Test version argument"""
+        args = parse_args()
+        self.assertTrue(args.version)
+        self.assertFalse(args.set)
+        self.assertFalse(args.clear)
+
+    @mock.patch.object(sys, "argv", new=["ttm", "--clear"])
+    def test_parse_args_clear(self):
+        """Test clear argument"""
+        args = parse_args()
+        self.assertFalse(args.version)
+        self.assertFalse(args.set)
+        self.assertTrue(args.clear)
+
+
+class TestMainFunction(unittest.TestCase):
+    """Test main() function logic"""
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.version", return_value="1.2.3")
+    @mock.patch("builtins.print")
+    def test_main_version(self, mock_print, _mock_version, mock_parse_args):
+        """Test main function with version argument"""
+        mock_parse_args.return_value = mock.Mock(
+            version=True, set=None, clear=False, tool_debug=False
+        )
+        ret = main()
+        mock_print.assert_called_with("1.2.3")
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    @mock.patch("builtins.print")
+    def test_main_set_invalid(self, mock_print, _mock_tool, mock_parse_args):
+        """Test main function with invalid set argument"""
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=0, clear=False, tool_debug=False
+        )
+        ret = main()
+        mock_print.assert_called_with("Error: GB value must be greater than 0")
+        self.assertEqual(ret, 1)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_set_valid(self, mock_tool, mock_parse_args):
+        """Test main function with set argument"""
+        instance = mock_tool.return_value
+        instance.set.return_value = True
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=2, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.set.assert_called_with(2)
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_set_failed(self, mock_tool, mock_parse_args):
+        instance = mock_tool.return_value
+        instance.set.return_value = False
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=2, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.set.assert_called_with(2)
+        self.assertEqual(ret, 1)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_clear_success(self, mock_tool, mock_parse_args):
+        """Test main function with clear argument"""
+        instance = mock_tool.return_value
+        instance.clear.return_value = True
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=True, tool_debug=False
+        )
+        ret = main()
+        instance.clear.assert_called_once()
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_clear_failed(self, mock_tool, mock_parse_args):
+        """Test main function with clear argument failure"""
+        instance = mock_tool.return_value
+        instance.clear.return_value = False
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=True, tool_debug=False
+        )
+        ret = main()
+        instance.clear.assert_called_once()
+        self.assertEqual(ret, 1)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_get_success(self, mock_tool, mock_parse_args):
+        """Test main function with get argument"""
+        instance = mock_tool.return_value
+        instance.get.return_value = True
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.get.assert_called_once()
+        self.assertIsNone(ret)
+
+    @mock.patch("amd_debug.ttm.parse_args")
+    @mock.patch("amd_debug.ttm.AmdTtmTool")
+    def test_main_get_failed(self, mock_tool, mock_parse_args):
+        """Test main function with get argument failure"""
+        instance = mock_tool.return_value
+        instance.get.return_value = False
+        mock_parse_args.return_value = mock.Mock(
+            version=False, set=None, clear=False, tool_debug=False
+        )
+        ret = main()
+        instance.get.assert_called_once()
+        self.assertEqual(ret, 1)
+
+
+class TestMaybeReboot(unittest.TestCase):
+    """Test maybe_reboot function"""
+
+    @mock.patch("builtins.input", return_value="y")
+    @mock.patch("amd_debug.ttm.reboot", return_value=True)
+    def test_maybe_reboot_yes(self, mock_reboot, _mock_input):
+        """Test reboot confirmation and execution"""
+        result = maybe_reboot()
+        mock_reboot.assert_called_once()
+        self.assertTrue(result)
+
+    @mock.patch("builtins.input", return_value="n")
+    @mock.patch("amd_debug.ttm.reboot", return_value=True)
+    def test_maybe_reboot_no(self, mock_reboot, _mock_input):
+        """Test reboot confirmation without execution"""
+        result = maybe_reboot()
+        mock_reboot.assert_not_called()
+        self.assertTrue(result)
+
+
+class TestAmdTtmTool(unittest.TestCase):
+    """Unit tests for AmdTtmTool class"""
+
+    def setUp(self):
+        self.tool = AmdTtmTool(logging=False)
+
+    @mock.patch("builtins.open", new_callable=mock.mock_open, read_data="4096")
+    @mock.patch("amd_debug.ttm.bytes_to_gb", return_value=4.0)
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=16.0)
+    def test_get_success(self, _mock_mem, mock_print, _mock_bytes_to_gb, mock_open):
+        """Test get() when TTM_PARAM_PATH exists"""
+        result = self.tool.get()
+        mock_open.assert_called_once_with(
+            "/sys/module/ttm/parameters/pages_limit", "r", encoding="utf-8"
+        )
+        mock_print.assert_any_call(
+            "Current TTM pages limit: 4096 pages (4.00 GB)", "💻"
+        )
+        mock_print.assert_any_call("Total system memory: 16.00 GB", "💻")
+        self.assertTrue(result)
+
+    @mock.patch("builtins.open", side_effect=FileNotFoundError)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_get_file_not_found(self, mock_print, _mock_open):
+        """Test get() when TTM_PARAM_PATH does not exist"""
+        result = self.tool.get()
+        mock_print.assert_called_with(
+            "Error: Could not find /sys/module/ttm/parameters/pages_limit", "❌"
+        )
+        self.assertFalse(result)
+
+    @mock.patch("amd_debug.ttm.relaunch_sudo", return_value=True)
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=8.0)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_set_gb_greater_than_total(
+        self, mock_print, _mock_mem, _mock_relaunch_sudo
+    ):
+        """Test set() when gb_value > total system memory"""
+        result = self.tool.set(16)
+        mock_print.assert_any_call(
+            "16.00 GB is greater than total system memory (8.00 GB)", "❌"
+        )
+        self.assertFalse(result)
+
+    @mock.patch("amd_debug.ttm.relaunch_sudo", return_value=True)
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=10.0)
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("builtins.input", return_value="n")
+    def test_set_gb_exceeds_max_percentage_cancel(
+        self, _mock_input, mock_print, _mock_mem, mock_relaunch_sudo
+    ):
+        """Test set() when gb_value exceeds max percentage and user cancels"""
+        result = self.tool.set(9.5)
+        self.assertFalse(result)
+        mock_print.assert_any_call("Operation cancelled.", "🚦")
+
+    @mock.patch("amd_debug.ttm.relaunch_sudo", return_value=True)
+    @mock.patch("amd_debug.ttm.get_system_mem", return_value=10.0)
+    @mock.patch("amd_debug.ttm.gb_to_pages", return_value=20480)
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("builtins.open", new_callable=mock.mock_open)
+    @mock.patch("builtins.input", return_value="y")
+    @mock.patch("amd_debug.ttm.maybe_reboot", return_value=True)
+    def test_set_success(
+        self,
+        _mock_reboot,
+        _mock_input,
+        mock_open,
+        mock_print,
+        _mock_gb_to_pages,
+        _mock_mem,
+        _relaunch_sudo,
+    ):
+        """Test set() success path"""
+        result = self.tool.set(5)
+        mock_open.assert_called_once_with(
+            "/etc/modprobe.d/ttm.conf", "w", encoding="utf-8"
+        )
+        mock_print.assert_any_call(
+            "Successfully set TTM pages limit to 20480 pages (5.00 GB)", "🐧"
+        )
+        self.assertTrue(result)
+
+    @mock.patch("os.path.exists", return_value=False)
+    @mock.patch("amd_debug.ttm.print_color")
+    def test_clear_file_not_exists(self, mock_print, _mock_exists):
+        """Test clear() when config file does not exist"""
+        result = self.tool.clear()
+        mock_print.assert_called_with("/etc/modprobe.d/ttm.conf doesn't exist", "❌")
+        self.assertFalse(result)
+
+    @mock.patch("os.path.exists", return_value=True)
+    @mock.patch("amd_debug.ttm.relaunch_sudo", return_value=True)
+    @mock.patch("os.remove")
+    @mock.patch("amd_debug.ttm.print_color")
+    @mock.patch("amd_debug.ttm.maybe_reboot", return_value=True)
+    def test_clear_success(
+        self, _mock_reboot, mock_print, mock_remove, _mock_relaunch_sudo, _mock_exists
+    ):
+        """Test clear() success path"""
+        result = self.tool.clear()
+        mock_remove.assert_called_once_with("/etc/modprobe.d/ttm.conf")
+        mock_print.assert_any_call(
+            "Configuration /etc/modprobe.d/ttm.conf removed", "🐧"
+        )
+        self.assertTrue(result)

test_validator.py

@@ -44,7 +44,7 @@ class TestValidatorHelpers(unittest.TestCase):
             return "Test function executed"
 
         # Mock /sys/power/pm_debug_messages existing and all ACPI existing
-        with patch("builtins.open", new_callable=mock_open, read_data="0") as mock_file:
+        with patch("amd_debug.validator.open", new_callable=mock_open, read_data="0") as mock_file:
             handlers = (
                 mock_file.return_value,
                 mock_open(read_data="0").return_value,
@@ -57,7 +57,7 @@ class TestValidatorHelpers(unittest.TestCase):
 
         # Mock /sys/power/pm_debug_messages missing
         with patch(
-            "builtins.open", side_effect=FileNotFoundError("not found")
+            "amd_debug.validator.open", side_effect=FileNotFoundError("not found")
         ) as mock_file:
             with self.assertRaises(FileNotFoundError):
                 result = test_function()
@@ -71,7 +71,8 @@ class TestValidator(unittest.TestCase):
         logging.basicConfig(filename="/dev/null", level=logging.DEBUG)
 
     @patch("amd_debug.validator.SleepDatabase")
-    def setUp(self, _db_mock):
+    @patch("subprocess.run")
+    def setUp(self, _db_mock, _mock_run):
         """Set up a mock context for testing"""
         self.validator = SleepValidator(tool_debug=True, bios_debug=False)
 
@@ -263,7 +264,7 @@ class TestValidator(unittest.TestCase):
 
         # Validate debug messages
         mock_record_debug.assert_called_once_with(
-            "Woke up from input source /sys/devices/input0 (3->5)", "💤"
+            "Woke up from input source /sys/devices/input0 (3->5)"
         )
 
         # Stop patches
@@ -556,7 +557,7 @@ class TestValidator(unittest.TestCase):
             # Set attributes for record_cycle
             self.validator.requested_duration = 60
             self.validator.active_gpios = ["GPIO1"]
-            self.validator.wakeup_irqs = [5]
+            self.validator.wakeup_irqs = ["5"]
             self.validator.kernel_duration = 1.5
             self.validator.hw_sleep_duration = 1.0
 
@@ -579,10 +580,10 @@ class TestValidator(unittest.TestCase):
             # Assert record_cycle was called with correct arguments
             mock_record_cycle.assert_called_once_with(
                 self.validator.requested_duration,
-                self.validator.active_gpios,
-                self.validator.wakeup_irqs,
-                self.validator.kernel_duration,
-                self.validator.hw_sleep_duration,
+                ",".join(str(gpio) for gpio in self.validator.active_gpios),
+                ",".join(str(irq) for irq in self.validator.wakeup_irqs),
+                int(self.validator.kernel_duration),
+                int(self.validator.hw_sleep_duration),
             )
 
     def test_program_wakealarm(self):
@@ -830,3 +831,64 @@ class TestValidator(unittest.TestCase):
         )
         mock_os_write.assert_called_once_with(3, b"mem")
         mock_os_close.assert_called_once_with(3)
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_file_not_exists(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia returns True if NVIDIA suspend file does not exist"""
+        mock_exists.return_value = False
+        result = self.validator.toggle_nvidia(b"suspend")
+        self.assertTrue(result)
+        mock_open.assert_not_called()
+        mock_write.assert_not_called()
+        mock_close.assert_not_called()
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_success(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia writes value and returns True on success"""
+        mock_exists.return_value = True
+        mock_open.return_value = 42
+        mock_write.return_value = None
+        with patch.object(self.validator.db, "record_debug") as mock_record_debug:
+            result = self.validator.toggle_nvidia(b"suspend")
+            self.assertTrue(result)
+            mock_open.assert_called_once_with(
+                "/proc/driver/nvidia/suspend", os.O_WRONLY | os.O_SYNC
+            )
+            mock_write.assert_called_once_with(42, b"suspend")
+            mock_close.assert_called_once_with(42)
+            mock_record_debug.assert_called_once_with(
+                "Wrote b'suspend' to NVIDIA driver"
+            )
+
+    @patch("os.path.exists")
+    @patch("os.open")
+    @patch("os.write")
+    @patch("os.close")
+    def test_toggle_nvidia_oserror(
+        self, mock_close, mock_write, mock_open, mock_exists
+    ):
+        """Test toggle_nvidia handles OSError and returns False"""
+        mock_exists.return_value = True
+        mock_open.return_value = 99
+        mock_write.side_effect = OSError("write error")
+        with patch.object(
+            self.validator.db, "record_cycle_data"
+        ) as mock_record_cycle_data:
+            result = self.validator.toggle_nvidia(b"resume")
+            self.assertFalse(result)
+            mock_open.assert_called_once_with(
+                "/proc/driver/nvidia/suspend", os.O_WRONLY | os.O_SYNC
+            )
+            mock_write.assert_called_once_with(99, b"resume")
+            mock_close.assert_called_once_with(99)
+            mock_record_cycle_data.assert_called_once()

amd_debug_tools-0.2.5.dist-info/METADATA

@@ -1,181 +0,0 @@
-Metadata-Version: 2.4
-Name: amd-debug-tools
-Version: 0.2.5
-Summary: debug tools for AMD systems
-Author-email: Mario Limonciello <superm1@kernel.org>
-License-Expression: MIT
-Project-URL: Homepage, https://web.git.kernel.org/pub/scm/linux/kernel/git/superm1/amd-debug-tools.git/
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyudev
-Requires-Dist: packaging
-Requires-Dist: pandas
-Requires-Dist: jinja2
-Requires-Dist: tabulate
-Requires-Dist: seaborn
-Requires-Dist: cysystemd
-Requires-Dist: Jinja2
-Requires-Dist: matplotlib
-Requires-Dist: seaborn
-Dynamic: license-file
-
-# Helpful tools for debugging AMD Zen systems
-[![codecov](https://codecov.io/github/superm1/amd-debug-tools/graph/badge.svg?token=Z9WTBZADGT)](https://codecov.io/github/superm1/amd-debug-tools)
-[![PyPI](https://img.shields.io/pypi/v/amd-debug-tools.svg)](https://pypi.org/project/amd-debug-tools/)
-
-This repository hosts open tools that are useful for debugging issues on AMD systems.
-
-## Installation
-It is suggested to install tools in a virtual environment either using
-`pipx` or `python3 -m venv`.
-
-### From PyPI
-`amd-debug-tools` is distributed as a python wheel, which is a
-binary package format for Python. To install from PyPI, run the following
-command:
-
-    pipx install amd-debug-tools
-
-### From source
-To build the package from source, you will need to the `python3-build`
-package natively installed by your distribution package manager. Then you
-can generate and install a wheel by running the following commands:
-
-    python3 -m build
-    pipx install dist/amd-debug-tools-*.whl
-
-### Ensuring path
-If you have not used a `pipx` environment before, you may need to run the following command
-to set up the environment:
-
-    pipx ensurepath
-
-This will add the `pipx` environment to your path.
-
-### Running in tree
-If you want to run the tools in tree, you need to make sure that distro dependencies
-that would normally install into a venv are installed. This can be done by running:
-
-    ./install_deps.py
-
-After dependencies are installed, you can run the tools by running:
-
-    ./amd_s2idle.py
-    ./amd_bios.py
-    ./amd_pstate.py
-
-## amd-s2idle
-`amd-s2idle` is a tool used for analyzing the entry and exit of the s2idle
-state of a Linux system.
-
-It is intended to use with Linux kernel 6.1 or later and works by hooking
-into dynamic debugging messages and events that are generated by the kernel.
-
-For analysis of power consumption issues it can be hooked into `systemd` to
-run a command to capture data right before and after the system enters and
-exits the s2idle state.
-
-4 high level commands are supported.
-
-### `amd-s2idle install`
-This will install the systemd hook so that data will be captured before and
-after the system enters and exits the s2idle state.
-
-This will also install a bash completion script that can be used for other
-commands.
-
-**NOTE:** This command is only supported when run from a venv.
-
-### `amd-s2idle uninstall`
-This will uninstall the systemd hook and remove the bash completion script.
-
-**NOTE:** This command is only supported when run from a venv.
-
-### `amd-s2idle test`
-This will run a suspend cycle with a timer based wakeup and capture relevant
-data into a database and produce a report. This can also be used to run multiple cycles.
-
-The following optional arguments are supported for this command:
-
-        --count COUNT         Number of cycles to run
-        --duration DURATION   Duration of the cycle in seconds
-        --wait WAIT           Time to wait before starting the cycle in seconds
-        --format FORMAT       Format of the report to produce (html, txt or md)
-        --report-file         File to write the report to
-        --force               Run a test cycle even if the system fails to pass prerequisite checks
-        --random              Run sleep cycles for random durations and waits, using the --duration and --wait arguments as an upper bound
-        --logind              Use logind to suspend the system
-        --tool-debug          Enable debug logging
-        --bios-debug          Enable BIOS debug logging instead of notify logging
-
-If the tool is launched with an environment that can call `xdg-open`, the report
-will be opened in a browser.
-
-### `amd-s2idle report`
-This will produce a report from the data captured by the `test` command
-and/or from the systemd hook.  The report will default to 60 days of data.
-
-The following optional arguments are supported for this command:
-
-        --since SINCE         Date to start the report from
-        --until UNTIL         Date to end the report at
-        --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
-        --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-s2idle version`
-This will print the version of the tool and exit.
-
-### Debug output
-All commands support the `--tool-debug` argument which will enable extra debug output. This is often needed for debugging issues with a particular cycle.
-
-**NOTE:** enabling debug output significantly increases the size of the report.
-It's suggested that you use `--since` and `--until` to focus on the cycles that you are interested in.
-
-## amd-bios
-`amd-bios` is a a tool that can be used to enable or disable BIOS AML debug logging
--and to parse a kernel log that contains BIOS logs.
-
-### `amd-bios trace`
-Modify BIOS AML trace debug logging.
-
-One of the following arguments must be set for this command:
-
-        --enable       Enable BIOS AML tracing
-        --disable      Disable BIOS AML tracing
-
-The following optional arguments are supported for this command:
-
-        --tool-debug   Enable tool debug logging
-
-### `amd-bios parse`
-Parses a kernel log that contains BIOS AML debug logging and produces a report.
-
-The following optional arguments are supported for this command:
-
-        --input INPUT  Optional input file to parse
-        --tool-debug   Enable tool debug logging
-
-### `amd-bios version`
-This will print the version of the tool and exit.
-
-## amd-pstate
-`amd-pstate` is a tool used for identification of issues with amd-pstate.
-It will capture some state from the system as well as from the machine specific registers that
-amd-pstate uses.
-
-## Compatibility scripts
-
-Compatibility scripts are provided for the previous names the tools went by:
-`amd_s2idle.py`, `amd_bios.py` and `amd_pstate.py`.
-These allow cloning the repository and running the scripts without installing
-the package.
-