adjustor 3.0.1__tar.gz → 3.1.0__tar.gz

adjustor-3.1.0/MANIFEST.in

@@ -0,0 +1,4 @@
+recursive-include src/adjustor *.yml
+recursive-include src/adjustor *.yaml
+recursive-include src/adjustor *.xml.in
+graft usr/

{adjustor-3.0.1/src/adjustor.egg-info → adjustor-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: adjustor
-Version: 3.0.1
+Version: 3.1.0
 Summary: Adjustor, a userspace program for managing the TDP of handheld devices.
 Author-email: Kapenekakis Antheas <pypi@antheas.dev>
 Project-URL: Homepage, https://github.com/hhd-dev/adjustor
@@ -16,6 +16,8 @@ License-File: LICENSE
 Requires-Dist: rich>=13.5.2
 Requires-Dist: pyroute2>=0.7.3
 Requires-Dist: fuse-python>=1.0.7
+Requires-Dist: PyGObject>=3.46.0
+Requires-Dist: dbus-python>=1.3.2
 
 # Adjustor
 Home of the Adjustor TDP plugin for Handheld Daemon.

{adjustor-3.0.1 → adjustor-3.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adjustor"
-version = "3.0.1"
+version = "3.1.0"
 authors = [
   { name="Kapenekakis Antheas", email="pypi@antheas.dev" },
 ]
@@ -19,6 +19,8 @@ dependencies = [
   "rich>=13.5.2",
   "pyroute2>=0.7.3",
   "fuse-python>=1.0.7",
+  "PyGObject>=3.46.0",
+  "dbus-python>=1.3.2",
 ]
 
 [project.urls]

{adjustor-3.0.1 → adjustor-3.1.0}/src/adjustor/core/const.py

@@ -1,11 +1,16 @@
 from .alib import A, D, DeviceParams, AlibParams
 
-ROG_ALLY_PP_MAP = [
+PLATFORM_PROFILE_MAP = [
     ("low-power", 0),
     ("quiet", 0),
     ("balanced", 13),
     ("performance", 20),
 ]
+ENERGY_MAP = [
+    ("power", 0),
+    ("balanced", 13),
+    ("performance", 20),
+]
 
 ALIB_PARAMS = {
     # TDPs

adjustor-3.1.0/src/adjustor/drivers/amd/__init__.py

@@ -0,0 +1,325 @@
+import logging
+import os
+import subprocess
+import sys
+from threading import Event as TEvent
+from threading import Thread
+from typing import Literal
+import time
+
+from hhd.plugins import Context, HHDPlugin, load_relative_yaml
+from hhd.plugins.conf import Config
+
+from adjustor.fuse.gpu import (
+    get_igpu_status,
+    set_cpu_boost,
+    set_epp_mode,
+    set_gpu_auto,
+    set_gpu_manual,
+    set_powersave_governor,
+    can_use_nonlinear,
+    set_frequency_scaling,
+)
+
+logger = logging.getLogger(__name__)
+
+APPLY_DELAY = 0.5
+
+
+def _ppd_client(emit, proc):
+    os.set_blocking(proc.stdin.fileno(), False)
+
+    while True:
+        if proc.poll() is not None:
+            break
+        line = proc.stdout.readline().decode().strip()
+        if not line:
+            break
+        if line not in ("power", "balanced", "performance"):
+            logger.error(f"Invalid PPD mode: {line}")
+            continue
+        emit({"type": "ppd", "status": line})
+
+
+def _open_ppd_server(emit):
+    logger.info("Launching PPD server.")
+    proc = subprocess.Popen(
+        [sys.executable, "-m", "adjustor.drivers.amd.ppd"],
+        stdout=subprocess.PIPE,
+        stdin=subprocess.PIPE,
+    )
+    t = Thread(target=_ppd_client, args=(emit, proc))
+    t.start()
+    return proc, t
+
+
+class AmdGPUPlugin(HHDPlugin):
+
+    def __init__(
+        self,
+    ) -> None:
+        self.name = f"adjustor_ppd"
+        self.priority = 8
+        self.log = "agpu"
+        self.core_available = False
+        self.core_enabled = False
+        self.enabled = False
+        self.ppd_conflict = False
+        self.initialized = False
+        self.supports_boost = False
+
+        self.proc = None
+        self.t = None
+
+        self.queue = None
+        self.old_ppd = False
+        self.old_gpu = None
+        self.old_freq = None
+        self.old_boost = None
+        self.old_epp = None
+        self.old_target = None
+        self.old_min_freq = None
+        self.target: Literal["power", "balanced", "performance"] = "balanced"
+
+        self.logged_boost = False
+        self.logged_error = False
+
+    def settings(self):
+        if not self.core_enabled:
+            self.initialized = False
+            self.core_available = False
+            return {}
+
+        status = get_igpu_status()
+        if not status:
+            self.core_available = False
+            if not self.logged_error:
+                logger.error(
+                    "Could not get frequency status. Disabling AMD GPU plugin."
+                )
+                self.logged_error = True
+            return {}
+
+        sets = load_relative_yaml("./settings.yml")
+        self.core_available = True
+        if not self.enabled:
+            self.initialized = False
+            return {"hhd": {"settings": sets["core"]}}
+
+        self.ppd_conflict = False
+        try:
+            out = subprocess.check_output(
+                [
+                    "systemctl",
+                    "list-units",
+                    "-t",
+                    "service",
+                    "--full",
+                    "--all",
+                    "--plain",
+                    "--no-legend",
+                ]
+            )
+            for line in out.decode().splitlines():
+                if "power-profiles-daemon" in line or "tuned" in line.lower():
+                    self.ppd_conflict = True
+                    break
+        except Exception as e:
+            logger.error(f"Failed to check for PPD conflict:\n{e}")
+
+        if self.ppd_conflict:
+            self.initialized = False
+            return {
+                "tdp": {"amd_energy": sets["conflict"]},
+                "hhd": {"settings": sets["core"]},
+            }
+
+        self.initialized = True
+        freq = sets["enabled"]["children"]["mode"]["modes"]["manual"]["children"][
+            "gpu_freq"
+        ]["modes"]["manual"]["children"]["frequency"]
+        freq["min"] = status.freq_min
+        freq["max"] = status.freq_max
+        freq["default"] = ((status.freq_min + status.freq_max) // 200) * 100
+
+        self.supports_boost = status.cpu_boost is not None
+        if self.supports_boost:
+            if not self.logged_boost:
+                logger.info(f"CPU Boost toggling is supported.")
+        else:
+            if not self.logged_boost:
+                logger.warning(f"CPU Boost toggling is not supported.")
+            del sets["enabled"]["children"]["mode"]["manual"]["children"]["cpu_boost"]
+
+        self.supports_nonlinear = can_use_nonlinear()
+        if not self.supports_nonlinear:
+            del sets["enabled"]["children"]["mode"]["modes"]["manual"]["children"][
+                "cpu_min_freq"
+            ]
+
+        self.supports_epp = status.epp_avail is not None
+        if self.supports_epp:
+            epp = sets["enabled"]["children"]["mode"]["modes"]["manual"]["children"][
+                "cpu_pref"
+            ]
+            epp["options"] = {
+                k: v for k, v in epp["options"].items() if k in status.epp_avail
+            }
+        else:
+            del sets["enabled"]["children"]["mode"]["modes"]["manual"]["children"][
+                "cpu_pref"
+            ]
+
+        self.logged_boost = True
+        return {
+            "tdp": {"amd_energy": sets["enabled"]},
+            "hhd": {"settings": sets["core"]},
+        }
+
+    def open(
+        self,
+        emit,
+        context: Context,
+    ):
+        self.emit = emit
+
+    def notify(self, events):
+        for event in events:
+            if event["type"] == "energy":
+                self.target = event["status"]
+                try:
+                    if self.proc and self.proc.stdin:
+                        self.proc.stdin.write(f"{self.target}\n".encode())
+                        self.proc.stdin.flush()
+                except Exception as e:
+                    logger.error(f"Failed to send PPD mode:\n{e}")
+                    self.close()
+
+    def update(self, conf: Config):
+        self.core_enabled = conf["hhd.settings.tdp_enable"].to(bool)
+        if not self.core_enabled or not self.core_available:
+            return
+
+        enabled = conf["hhd.settings.amd_energy_enable"].to(bool)
+        if enabled != self.enabled:
+            self.emit({"type": "settings"})
+        self.enabled = enabled
+
+        if self.ppd_conflict and conf.get("tdp.amd_energy.enable", False):
+            conf["tdp.amd_energy.enable"] = False
+            self.emit({"type": "settings"})
+
+        if not self.initialized:
+            return
+
+        new_ppd = conf["hhd.settings.amd_energy_ppd"].to(bool)
+        if new_ppd != self.old_ppd:
+            self.old_ppd = new_ppd
+            if new_ppd:
+                try:
+                    self.proc, self.t = _open_ppd_server(self.emit)
+                except Exception as e:
+                    logger.error(f"Failed to open PPD server:\n{e}")
+                    self.close()
+            else:
+                self.close()
+
+        if conf["tdp.amd_energy.mode.mode"].to(str) == "auto":
+            curr = time.perf_counter()
+            if self.target != self.old_target:
+                self.old_target = self.target
+                self.queue = curr + APPLY_DELAY
+
+            if self.queue is not None and curr >= self.queue:
+                self.queue = None
+                logger.info(
+                    f"Handling energy settings for power profile '{self.target}'."
+                )
+                try:
+                    match self.target:
+                        case "balanced":
+                            set_gpu_auto()
+                            if self.supports_boost:
+                                set_cpu_boost(True)
+                            if self.supports_epp:
+                                set_powersave_governor()
+                                set_epp_mode("balance_power")
+                            set_frequency_scaling(nonlinear=False)
+                        case "performance":
+                            set_gpu_auto()
+                            if self.supports_boost:
+                                set_cpu_boost(True)
+                            if self.supports_epp:
+                                set_powersave_governor()
+                                set_epp_mode("balance_power")
+                            set_frequency_scaling(nonlinear=True)
+                        case _:  # power
+                            set_gpu_auto()
+                            if self.supports_boost:
+                                set_cpu_boost(False)
+                            if self.supports_epp:
+                                set_powersave_governor()
+                                set_epp_mode("power")
+                            set_frequency_scaling(False)
+                except Exception as e:
+                    logger.error(f"Failed to set mode:\n{e}")
+
+            self.old_gpu = None
+            self.old_freq = None
+            self.old_boost = None
+            self.old_epp = None
+            self.old_min_freq = None
+        else:
+            self.old_target = None
+            new_gpu = conf["tdp.amd_energy.mode.manual.gpu_freq.mode"].to(str)
+            new_freq = conf["tdp.amd_energy.mode.manual.gpu_freq.manual.frequency"].to(
+                int
+            )
+            if new_gpu != self.old_gpu or new_freq != self.old_freq:
+                self.old_gpu = new_gpu
+                self.old_freq = new_freq
+
+                try:
+                    if new_gpu == "manual":
+                        set_gpu_manual(new_freq)
+                    else:
+                        set_gpu_auto()
+                except Exception as e:
+                    logger.error(f"Failed to set GPU mode:\n{e}")
+
+            if self.supports_boost:
+                new_boost = conf["tdp.amd_energy.mode.manual.cpu_boost"].to(bool)
+                if new_boost != self.old_boost:
+                    self.old_boost = new_boost
+                    try:
+                        set_cpu_boost(new_boost == "enabled")
+                    except Exception as e:
+                        logger.error(f"Failed to set CPU boost:\n{e}")
+
+            if self.supports_epp:
+                new_epp = conf["tdp.amd_energy.mode.manual.cpu_pref"].to(str)
+                if new_epp != self.old_epp:
+                    self.old_epp = new_epp
+                    try:
+                        # Set governor to powersave as well
+                        set_powersave_governor()
+                        set_epp_mode(new_epp)  # type: ignore
+                    except Exception as e:
+                        logger.error(f"Failed to set EPP mode:\n{e}")
+
+            if self.supports_nonlinear:
+                new_min_freq = conf["tdp.amd_energy.mode.manual.cpu_min_freq"].to(int)
+                if new_min_freq != self.old_min_freq:
+                    self.old_min_freq = new_min_freq
+                    try:
+                        set_frequency_scaling(nonlinear=new_min_freq == "nonlinear")
+                    except Exception as e:
+                        logger.error(f"Failed to set minimum CPU frequency:\n{e}")
+
+    def close(self):
+        if self.proc is not None:
+            self.proc.terminate()
+            self.proc.wait()
+        if self.t is not None:
+            self.t.join()
+            self.t = None

adjustor-3.1.0/src/adjustor/drivers/amd/power-profiles-daemon.dbus.xml.in

@@ -0,0 +1,147 @@
+<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+
+<node>
+
+  <!--
+      @dbus_iface@:
+      @short_description: Power Profiles daemon
+
+      The power-profiles-daemon API is meant to be used by parts of the OS or
+      desktop environment to switch system power profiles based on user choice,
+      or user intent.
+
+      OS components would typically use the "Profiles" property to construct
+      their UI (2 or 3 profiles available), and monitor the "ActiveProfile"
+      and the "PerformanceDegraded" properties to update that UI. The UI
+      would try to set the "ActiveProfile" property if the user selected
+      a different one.
+
+      Note that the reason why the project exists and how it is different from
+      existing projects is explained <ulink href=" https://gitlab.freedesktop.org/hadess/power-profiles-daemon/-/blob/master/README.md">
+      in the project's README file</ulink>.
+
+      The object path will be "@dbus_path@".
+  -->
+  <interface name="@dbus_iface@">
+
+    <!--
+        HoldProfile:
+
+        This forces the passed profile (either 'power-saver' or 'performance')
+        to be activated until either the caller quits, "ReleaseProfile" is
+        called, or the "ActiveProfile" is changed by the user.
+
+        This should be used programmatically by OS components when, eg. high-
+        performance workloads are started with the "performance" profile, or
+        battery will soon be critically low with the "power-saver" profile.
+
+        When conflicting profiles are requested to be held, the 'power-saver' profile
+        will be activated in preference to the 'performance' profile.
+
+        Those holds will be automatically cancelled if the user manually switches
+        to another profile, and the "ProfileReleased" signal will be emitted.
+    -->
+    <method name="HoldProfile">
+      <arg name="profile" type="s" direction="in"/>
+      <arg name="reason" type="s" direction="in"/>
+      <arg name="application_id" type="s" direction="in" />
+      <arg name="cookie" type="u" direction="out"/>
+    </method>
+
+    <!--
+        ReleaseProfile:
+
+        This removes the hold that was set on a profile.
+    -->
+    <method name="ReleaseProfile">
+      <arg name="cookie" type="u" direction="in"/>
+    </method>
+
+    <!--
+        ProfileReleased:
+
+        This signal will be emitted if the profile is released because the
+        "ActiveProfile" was manually changed. The signal will only be emitted
+        to the process that originally called "HoldProfile".
+    -->
+    <signal name="ProfileReleased">
+      <arg name="cookie" type="u" direction="out"/>
+    </signal>
+
+    <!--
+        ActiveProfile:
+
+        The type of the currently active profile. It might change automatically
+        if a profile is held, using the "HoldProfile" function.
+    -->
+    <property name="ActiveProfile" type="s" access="readwrite"/>
+
+    <!--
+        PerformanceInhibited:
+
+        This property is deprecated, and unused since version 0.9.
+    -->
+    <property name="PerformanceInhibited" type="s" access="read"/>
+
+    <!--
+        PerformanceDegraded:
+
+        This will be set if the performance power profile is running in degraded
+        mode, with the value being used to identify the reason for that degradation.
+        As new reasons can be added, it is recommended that front-ends show a generic
+        reason if they do not recognise the value. Possible values are:
+        - "lap-detected" (the computer is sitting on the user's lap)
+        - "high-operating-temperature" (the computer is close to overheating)
+        - "" (the empty string, if not performance is not degraded)
+    -->
+    <property name="PerformanceDegraded" type="s" access="read"/>
+
+    <!--
+        Profiles:
+
+        An array of key-pair values representing each profile. The key named
+        "Driver" (s) identifies the power-profiles-daemon backend code used to
+        implement the profile.
+
+        The key named "Profile" (s) will be one of:
+        - "power-saver" (battery saving profile)
+        - "balanced" (the default  profile)
+        - "performance" (a profile that does not care about noise or battery consumption)
+
+        Only one of each type of profile will be listed, with the daemon choosing the
+        more appropriate "driver" for each profile type.
+
+        This list is guaranteed to be sorted in the same order that the profiles
+        are listed above.
+    -->
+    <property name="Profiles" type="aa{sv}" access="read"/>
+
+    <!--
+        Actions:
+
+        An array of strings listing each one of the "actions" implemented in
+        the running daemon. This is used by API users to figure out whether
+        particular functionality is available in a version of the daemon.
+    -->
+    <property name="Actions" type="as" access="read"/>
+
+    <!--
+      ActiveProfileHolds:
+
+      A list of dictionaries representing the current profile holds.
+      The keys in the dict are "ApplicationId", "Profile" and "Reason",
+      and correspond to the "application_id", "profile" and "reason" arguments
+      passed to the HoldProfile() method.
+    -->
+    <property name="ActiveProfileHolds" type="aa{sv}" access="read"/>
+
+    <!--
+        Version:
+
+        The version of the power-profiles-daemon software.
+    -->
+    <property name="Version" type="s" access="read"/>
+
+  </interface>
+</node>

adjustor-3.1.0/src/adjustor/drivers/amd/ppd.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+
+import fcntl
+import os
+import sys
+
+import dbus
+import dbus.mainloop.glib
+import dbus.service
+from gi.repository import GLib
+
+BASE_NAME = "org.freedesktop.UPower.PowerProfiles"
+BASE_PATH = "/org/freedesktop/UPower/PowerProfiles"
+LEGACY_NAME = "net.hadess.PowerProfiles"
+LEGACY_PATH = "/net/hadess/PowerProfiles"
+XML_PATH = "power-profiles-daemon.dbus.xml.in"
+
+SUPPORTED_PROFILES = {
+    "performance": "performance",
+    "balanced": "balanced",
+    "power-saver": "power",
+}
+SUPPORTED_PROFILES_REVERSE = {v: k for k, v in SUPPORTED_PROFILES.items()}
+
+
+def load_introspect(legacy=False):
+    """Returns the yaml data of a file in the relative dir provided."""
+    import inspect
+    import os
+
+    script_fn = inspect.currentframe().f_back.f_globals["__file__"]  # type: ignore
+    dirname = os.path.dirname(script_fn)
+    with open(os.path.join(dirname, XML_PATH), "r") as f:
+        base = f.read()
+        return base.replace(
+            "@dbus_iface@", LEGACY_NAME if legacy else BASE_NAME
+        ).replace("@dbus_path@", LEGACY_PATH if legacy else BASE_PATH)
+
+
+def iface(legacy: bool):
+    return LEGACY_NAME if legacy else BASE_NAME
+
+
+def gpath(legacy: bool):
+    return LEGACY_PATH if legacy else BASE_PATH
+
+
+def create_interface(legacy: bool):
+    class HhdPpd(dbus.service.Object):
+
+        def __init__(self, conn=None):
+            self.profile_holds = []
+            self.actions = []
+            self.profile = "power-saver"  # next(iter(SUPPORTED_PROFILES))
+
+            super().__init__(conn, gpath(legacy), None)
+
+        @dbus.service.method(
+            dbus.INTROSPECTABLE_IFACE, in_signature="", out_signature="s"
+        )
+        def Introspect(self):
+            return load_introspect(legacy)
+
+        @dbus.service.method(
+            dbus.PROPERTIES_IFACE, in_signature="ss", out_signature="v"
+        )
+        def Get(self, interface_name, property_name):
+            return self.GetAll(interface_name)[property_name]
+
+        @dbus.service.method(
+            dbus.PROPERTIES_IFACE,
+            in_signature="s",
+            out_signature="a{sv}",
+            sender_keyword="sender",
+        )
+        def GetAll(self, interface_name, sender=None):
+            if interface_name == iface(legacy):
+                return {
+                    "Actions": dbus.Array(self.actions, signature="s"),
+                    "ActiveProfile": self.profile,
+                    "ActiveProfileHolds": dbus.Array(self.profile_holds, signature="u"),
+                    "PerformanceDegraded": "",
+                    "PerformanceInhibited": "",
+                    "Profiles": [{"Profile": p} for p in SUPPORTED_PROFILES],
+                    "Version": "0.21",
+                }
+            else:
+                raise dbus.exceptions.DBusException(
+                    "com.example.UnknownInterface",
+                    "Handheld daemon does not implement the %s interface."
+                    % interface_name,
+                )
+
+        @dbus.service.method(dbus.PROPERTIES_IFACE, in_signature="ssv")
+        def Set(self, interface_name, property_name, new_value):
+            # validate the property name and value, update internal state…
+            self.PropertiesChanged(interface_name, {property_name: new_value}, [])
+
+        @dbus.service.signal(dbus.PROPERTIES_IFACE, signature="sa{sv}as")
+        def PropertiesChanged(
+            self, interface_name, changed_properties, invalidated_properties
+        ):
+            if interface_name != iface(legacy):
+                return
+
+            for k, v in changed_properties.items():
+                if not k == "ActiveProfile":
+                    continue
+                if v not in SUPPORTED_PROFILES:
+                    continue
+                np = SUPPORTED_PROFILES[v]
+                if np == self.profile:
+                    continue
+                print(np, flush=True)
+
+        @dbus.service.method(iface(legacy), in_signature="sss", out_signature="u")
+        def HoldProfile(self, profile: str, reason: str, application_id: str):
+            # TODO
+            return 1
+
+        @dbus.service.method(iface(legacy), in_signature="u", out_signature="")
+        def ReleaseProfile(self, handle: int):
+            # TODO
+            self.ProfileReleased(handle)
+
+        @dbus.service.signal(iface(legacy), signature="u")
+        def ProfileReleased(self, handle: int):
+            # TODO
+            return handle
+
+        def update_profile(self):
+            for line in sys.stdin:
+                if not line:
+                    break
+                profile = line.strip()
+                if profile not in SUPPORTED_PROFILES_REVERSE:
+                    continue
+
+                self.profile = profile
+                self.PropertiesChanged(
+                    iface(legacy), {"ActiveProfile": self.profile}, []
+                )
+            return True
+
+    return HhdPpd
+
+
+if __name__ == "__main__":
+    mainloop = None
+    try:
+        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+        # set sys.stdin non-blocking
+        orig_fl = fcntl.fcntl(sys.stdin, fcntl.F_GETFL)
+        fcntl.fcntl(sys.stdin, fcntl.F_SETFL, orig_fl | os.O_NONBLOCK)
+
+        legacy = True
+        session_bus = dbus.SystemBus()
+        name = dbus.service.BusName(iface(legacy), session_bus)
+        object = create_interface(legacy)(session_bus)
+
+        GLib.timeout_add(100, object.update_profile)
+        mainloop = GLib.MainLoop()
+        mainloop.run()
+    except KeyboardInterrupt:
+        if mainloop:
+            mainloop.quit()