adjustor 3.7.6__tar.gz → 3.8.0__tar.gz

{adjustor-3.7.6/src/adjustor.egg-info → adjustor-3.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: adjustor
-Version: 3.7.6
+Version: 3.8.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

{adjustor-3.7.6 → adjustor-3.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "adjustor"
-version = "3.7.6"
+version = "3.8.0"
 authors = [
   { name="Kapenekakis Antheas", email="pypi@antheas.dev" },
 ]

{adjustor-3.7.6 → adjustor-3.8.0}/src/adjustor/core/const.py

@@ -27,17 +27,17 @@ class DevideProfile(TypedDict):
     alib: dict[str, AlibParams]
     dev: dict[str, DeviceParams]
 
-
-PLATFORM_PROFILE_MAP = [
-    ("low-power", 0),
-    ("quiet", 0),
-    ("balanced", 13),
-    ("performance", 20),
-]
+# internal name for ppd, platform_profile choices, min TDP for
+# profile to apply, tdp target to apply when selecting profile
 ENERGY_MAP = [
-    ("power", 0),
-    ("balanced", 13),
-    ("performance", 20),
+    ("power", ["low-power", "quiet"], 0, 8),
+    ("balanced", ["balanced"], 13, 15),
+    ("performance", ["performance"], 20, 25),
+]
+ENERGY_MAP_18W = [
+    ("low-power", ["low-power", "quiet"], 0, 5),
+    ("balanced", ["balanced"], 8, 12),
+    ("performance", ["performance"], 13, 18),
 ]
 
 ALIB_PARAMS = {
@@ -112,33 +112,48 @@ DEV_PARAMS_8040: dict[str, DeviceParams] = DEV_PARAMS_30W
 DEV_PARAMS_HX370: dict[str, DeviceParams] = DEV_PARAMS_30W
 DEV_PARAMS_LEGO = DEV_PARAMS_30W
 
-DEV_DATA: dict[str, tuple[dict[str, DeviceParams], dict[str, AlibParams], bool]] = {
-    "NEO-01": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False),
-    "V3": (DEV_PARAMS_28W, ALIB_PARAMS_8040, False),
-    "83E1": (DEV_PARAMS_LEGO, ALIB_PARAMS_7040, False),
-    "ONEXPLAYER F1Pro": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370, False),
-    "ONEXPLAYER F1 EVA-02": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370, False),
+DEV_DATA: dict[
+    str,
+    tuple[
+        dict[str, DeviceParams],
+        dict[str, AlibParams],
+        bool,
+        list[tuple[str, list[str], int, int]],
+    ],
+] = {
+    "NEO-01": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False, ENERGY_MAP),
+    "V3": (DEV_PARAMS_28W, ALIB_PARAMS_8040, False, ENERGY_MAP),
+    "83E1": (DEV_PARAMS_LEGO, ALIB_PARAMS_7040, False, ENERGY_MAP),
+    "ONEXPLAYER F1Pro": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370, False, ENERGY_MAP),
+    "ONEXPLAYER F1 EVA-02": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370, False, ENERGY_MAP),
     # GPD Devices are 28W max
-    "G1618-04": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False),
-    "G1617-01": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False),
-    "G1619-04": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False),
-    "G1619-05": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False),
+    "G1618-04": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False, ENERGY_MAP),
+    "G1617-01": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False, ENERGY_MAP),
+    "G1619-04": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False, ENERGY_MAP),
+    "G1619-05": (DEV_PARAMS_28W, ALIB_PARAMS_7040, False, ENERGY_MAP),
 }
 
-CPU_DATA: dict[str, tuple[dict[str, DeviceParams], dict[str, AlibParams]]] = {
-    "AMD Ryzen Z1 Extreme": (DEV_PARAMS_7040, ALIB_PARAMS_7040),
-    "AMD Ryzen Z1": (DEV_PARAMS_7040, ALIB_PARAMS_7040),
+CPU_DATA: dict[
+    str,
+    tuple[
+        dict[str, DeviceParams],
+        dict[str, AlibParams],
+        list[tuple[str, list[str], int, int]],
+    ],
+] = {
+    "AMD Ryzen Z1 Extreme": (DEV_PARAMS_7040, ALIB_PARAMS_7040, ENERGY_MAP),
+    "AMD Ryzen Z1": (DEV_PARAMS_7040, ALIB_PARAMS_7040, ENERGY_MAP),
     # Ayaneo AIR Pro, max is 18W
-    "AMD Ryzen 5 5560U": (DEV_PARAMS_18W, ALIB_PARAMS_5040),
+    "AMD Ryzen 5 5560U": (DEV_PARAMS_18W, ALIB_PARAMS_5040, ENERGY_MAP_18W),
     # 28W works fine, 30W is pushing it
-    "AMD Ryzen 7 5700U": (DEV_PARAMS_5000, ALIB_PARAMS_5040),
-    "AMD Ryzen 7 5800U": (DEV_PARAMS_5000, ALIB_PARAMS_5040),
+    "AMD Ryzen 7 5700U": (DEV_PARAMS_5000, ALIB_PARAMS_5040, ENERGY_MAP),
+    "AMD Ryzen 7 5800U": (DEV_PARAMS_5000, ALIB_PARAMS_5040, ENERGY_MAP),
     # GPD Win 4
     # model name    : AMD Ryzen 7 6800U with Radeon Graphics
-    "AMD Ryzen 7 6800U": (DEV_PARAMS_6000, ALIB_PARAMS_6040),
-    "AMD Ryzen 7 7840U": (DEV_PARAMS_7040, ALIB_PARAMS_7040),
-    "AMD Ryzen 7 8840U": (DEV_PARAMS_8040, ALIB_PARAMS_8040),
+    "AMD Ryzen 7 6800U": (DEV_PARAMS_6000, ALIB_PARAMS_6040, ENERGY_MAP),
+    "AMD Ryzen 7 7840U": (DEV_PARAMS_7040, ALIB_PARAMS_7040, ENERGY_MAP),
+    "AMD Ryzen 7 8840U": (DEV_PARAMS_8040, ALIB_PARAMS_8040, ENERGY_MAP),
     # AMD Athlon Silver 3050e (Win600, will it support tdp?)
-    "AMD Ryzen AI 9 HX 370": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370),
-    "AMD Ryzen AI HX 360": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370),
+    "AMD Ryzen AI 9 HX 370": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370, ENERGY_MAP),
+    "AMD Ryzen AI HX 360": (DEV_PARAMS_HX370, ALIB_PARAMS_HX370, ENERGY_MAP),
 }

{adjustor-3.7.6 → adjustor-3.8.0}/src/adjustor/drivers/amd/ppd.py

@@ -138,22 +138,24 @@ def create_interface(legacy: bool):
             # 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
+        def set_profile(self, profile):
+            if profile not in SUPPORTED_PROFILES_REVERSE:
+                return
 
-                self.profile = profile
-                self.PropertiesChanged(
-                    iface(legacy), {"ActiveProfile": self.profile}, []
-                )
-            return True
+            self.profile = SUPPORTED_PROFILES_REVERSE[profile]
+            self.PropertiesChanged(iface(legacy), {"ActiveProfile": self.profile}, [])
 
     return HhdPpd
 
+def update_profile(services):
+    for line in sys.stdin:
+        if not line:
+            break
+        profile = line.strip()
+        
+        for s in services:
+            s.set_profile(profile)
+    return True
 
 if __name__ == "__main__":
     mainloop = None
@@ -166,10 +168,30 @@ if __name__ == "__main__":
 
         legacy = False
         session_bus = dbus.SystemBus()
-        name = dbus.service.BusName(iface(legacy), session_bus)
-        object = create_interface(legacy)(session_bus)
+        
+        claimed = False
+        try:
+            name1 = dbus.service.BusName(iface(False), session_bus)
+            claimed = True
+        except Exception:
+            pass
+        
+        try:
+            name2 = dbus.service.BusName(iface(True), session_bus)
+            claimed = True
+        except Exception:
+            pass
+        
+        if not claimed:
+            sys.exit(1)
+
+        services = [
+            create_interface(False)(session_bus),
+            create_interface(True)(session_bus),
+        ]
+
+        GLib.timeout_add(100, lambda: update_profile(services))
 
-        GLib.timeout_add(100, object.update_profile)
         mainloop = GLib.MainLoop()
         mainloop.run()
     except KeyboardInterrupt:

{adjustor-3.7.6 → adjustor-3.8.0}/src/adjustor/drivers/asus/__init__.py

@@ -51,20 +51,6 @@ MIN_CURVE = [2, 5, 17, 17, 17, 17, 17, 17]
 DEFAULT_CURVE = [5, 10, 20, 35, 55, 75, 75, 75]
 
 
-def set_charge_limit(lim: int):
-    try:
-        # FIXME: Hardcoded path, should match using another characteristic
-        logger.info(f"Setting charge limit to {lim:d} %.")
-        with open(
-            "/sys/class/power_supply/BAT0/charge_control_end_threshold", "w"
-        ) as f:
-            f.write(f"{lim}\n")
-        return True
-    except Exception as e:
-        logger.error(f"Failed to write battery limit with error:\n{e}")
-        return False
-
-
 def set_tdp(pretty: str, fn: str, val: int):
     logger.info(f"Setting tdp value '{pretty}' to {val} by writing to:\n{fn}")
     try:
@@ -147,7 +133,6 @@ class AsusDriverPlugin(HHDPlugin):
 
         self.queue_fan = None
         self.queue_tdp = None
-        self.queue_charge_limit = None
         self.queue_extreme = time.perf_counter() + EXTREME_STARTUP_DELAY
         self.new_tdp = None
         self.new_mode = None
@@ -225,34 +210,6 @@ class AsusDriverPlugin(HHDPlugin):
 
         curr = time.perf_counter()
 
-        # Charge limit
-        lim = conf["tdp.asus.charge_limit"].to(str)
-        if (self.startup and lim != "disabled") or (
-            lim != self.old_conf["charge_limit"].to(str)
-        ):
-            self.queue_charge_limit = curr + APPLY_DELAY
-
-        if self.queue_charge_limit and self.queue_charge_limit < curr:
-            self.queue_charge_limit = None
-            match lim:
-                case "p65":
-                    set_charge_limit(65)
-                case "p70":
-                    set_charge_limit(70)
-                case "p80":
-                    set_charge_limit(80)
-                case "p85":
-                    set_charge_limit(85)
-                case "p90":
-                    set_charge_limit(90)
-                case "p95":
-                    set_charge_limit(95)
-                case "disabled":
-                    # Avoid writing charge limit on startup if
-                    # disabled
-                    if not self.startup:
-                        set_charge_limit(100)
-
         #
         # TDP
         #
@@ -508,8 +465,14 @@ class AsusDriverPlugin(HHDPlugin):
                     f"Waking up from sleep, resetting TDP after {SLEEP_DELAY} seconds."
                 )
                 self.queue_tdp = time.time() + SLEEP_DELAY
-            elif ev["type"] == "acpi" and ev["event"] in ("ac", "dc") and not self.queue_tdp:
-                logger.info(f"Power adapter status switched to '{ev['event']}', resetting TDP.")
+            elif (
+                ev["type"] == "acpi"
+                and ev["event"] in ("ac", "dc")
+                and not self.queue_tdp
+            ):
+                logger.info(
+                    f"Power adapter status switched to '{ev['event']}', resetting TDP."
+                )
                 self.queue_tdp = time.time() + APPLY_DELAY
             elif self.cycle_tdp and ev["type"] == "special" and ev["event"] == "xbox_y":
                 match self.mode:

{adjustor-3.7.6 → adjustor-3.8.0}/src/adjustor/drivers/asus/settings.yml

@@ -129,21 +129,6 @@ children:
             default: >-
               Asus hardware limits the minimum fan curve depending on TDP mode.
 
-  charge_limit:
-    type: multiple
-    title: Charge Limit (%)
-    tags: [ non-essential, ordinal ]
-    hint: >-
-      Applies a charge limit to the battery, 75% and up.
-    options:
-      p70: 70%
-      p80: 80%
-      p85: 85%
-      p90: 90%
-      p95: 95%
-      disabled: Unset
-    default: disabled
-
   extreme_standby:
     type: multiple
     title: Extreme Standby Mode

adjustor-3.8.0/src/adjustor/drivers/battery/__init__.py

@@ -0,0 +1,173 @@
+import logging
+import time
+from threading import Event as TEvent, Lock, Thread
+from typing import Sequence
+import os
+
+from hhd.plugins import Context, Event, HHDPlugin, load_relative_yaml
+from hhd.plugins.conf import Config
+
+from adjustor.core.alib import AlibParams, DeviceParams, alib
+from adjustor.core.fan import fan_worker, get_fan_info
+from adjustor.core.platform import get_platform_choices, set_platform_profile
+from adjustor.i18n import _
+
+logger = logging.getLogger(__name__)
+
+APPLY_DELAY = 0.7
+
+
+def set_charge_limit(bat: str, lim: int):
+    try:
+        logger.info(f"Setting charge limit to {lim:d} %.")
+        with open(bat, "w") as f:
+            f.write(f"{lim}\n")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to write battery limit with error:\n{e}")
+        return False
+
+
+def set_charge_bypass(bat: str, type: str):
+    match type:
+        case "disabled":
+            val = "Standard"
+        case "awake":
+            val = "BypassS0"
+        case "always":
+            val = "Bypass"
+        case _:
+            logger.error(f"Invalid charge bypass type: {type}")
+            return
+
+    try:
+        logger.info(f"Setting charge type to '{val}' (for bypass '{type}').")
+        with open(bat, "w") as f:
+            f.write(f"{val}\n")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to write battery bypass with error:\n{e}")
+        return False
+
+
+class BatteryPlugin(HHDPlugin):
+
+    def __init__(
+        self,
+    ) -> None:
+        self.name = f"adjustor_battery"
+        self.priority = 9
+        self.log = "batt"
+        self.enabled = False
+        self.initialized = False
+        self.startup = False
+
+        self.queue_charge_limit = None
+        self.charge_bypass_fn = None
+        self.charge_limit_fn = None
+        self.charge_bypass_prev = None
+        self.charge_limit_prev = None
+
+    def settings(self):
+        if not self.enabled:
+            self.initialized = False
+            return {}
+
+        self.initialized = True
+        out = {"tdp": {"battery": load_relative_yaml("battery.yml")}}
+
+        if not self.charge_limit_fn:
+            del out["tdp"]["battery"]["children"]["charge_limit"]
+        if not self.charge_bypass_fn:
+            del out["tdp"]["battery"]["children"]["charge_bypass"]
+
+        return out
+
+    def open(
+        self,
+        emit,
+        context: Context,
+    ):
+        self.emit = emit
+        self.startup = True
+
+        for bat in os.listdir("/sys/class/power_supply"):
+            if not bat.startswith("BAT"):
+                continue
+
+            with open(f"/sys/class/power_supply/{bat}/type") as f:
+                if "Battery" not in f.read():
+                    continue
+
+            base = f"/sys/class/power_supply/{bat}"
+            if os.path.exists(f"{base}/charge_control_end_threshold"):
+                self.charge_limit_fn = f"{base}/charge_control_end_threshold"
+            if os.path.exists(f"{base}/charge_type"):
+                try:
+                    with open("/sys/devices/virtual/dmi/id/sys_vendor") as f:
+                        supports = "ONE-NETBOOK" in f.read()
+                except Exception:
+                    supports = False
+
+                if supports:
+                    self.charge_bypass_fn = f"{base}/charge_type"
+                else:
+                    logger.warning(
+                        "Found charge type, but charge bypass is only supported on OneXPlayer currently."
+                    )
+            if self.charge_bypass_fn or self.charge_limit_fn:
+                logger.info(
+                    f"Found battery '{bat}' with:\nBattery Bypass:\n{self.charge_bypass_fn}\nBattery Limit:\n{self.charge_limit_fn}."
+                )
+                break
+
+    def update(self, conf: Config):
+        self.enabled = conf["hhd.settings.tdp_enable"].to(bool)
+
+        if not self.initialized:
+            return
+
+        curr = time.time()
+
+        if self.charge_bypass_fn:
+            bypass = conf["tdp.battery.charge_bypass"].to(str)
+            if self.charge_bypass_prev != bypass:
+                self.charge_bypass_prev = bypass
+
+                if bypass != "disabled" or not self.startup:
+                    set_charge_bypass(self.charge_bypass_fn, bypass)
+
+        # Charge limit
+        if self.charge_limit_fn:
+            lim = conf["tdp.battery.charge_limit"].to(str)
+            if lim != self.charge_limit_prev:
+                self.queue_charge_limit = curr + APPLY_DELAY
+                self.charge_limit_prev = lim
+
+            if self.startup or (
+                self.queue_charge_limit and self.queue_charge_limit < curr
+            ):
+                self.queue_charge_limit = None
+                self.charge_limit_prev = lim
+
+                match lim:
+                    case "p65":
+                        set_charge_limit(self.charge_limit_fn, 65)
+                    case "p70":
+                        set_charge_limit(self.charge_limit_fn, 70)
+                    case "p80":
+                        set_charge_limit(self.charge_limit_fn, 80)
+                    case "p85":
+                        set_charge_limit(self.charge_limit_fn, 85)
+                    case "p90":
+                        set_charge_limit(self.charge_limit_fn, 90)
+                    case "p95":
+                        set_charge_limit(self.charge_limit_fn, 95)
+                    case "disabled":
+                        # Avoid writing charge limit on startup if
+                        # disabled, so that if user does not use us
+                        # we do not overwrite their setting.
+                        if not self.startup:
+                            set_charge_limit(self.charge_limit_fn, 100)
+
+        self.startup = False

adjustor-3.8.0/src/adjustor/drivers/battery/battery.yml

@@ -0,0 +1,28 @@
+title: Battery Settings
+type: container
+tags: [ hide-title ]
+children:
+  charge_limit:
+    type: multiple
+    title: Charge Limit (%)
+    tags: [ non-essential, ordinal ]
+    hint: >-
+      Applies a charge limit to the battery, 75% and up.
+    options:
+      p70: 70%
+      p80: 80%
+      p85: 85%
+      p90: 90%
+      p95: 95%
+      disabled: Unset
+    default: disabled
+
+  charge_bypass:
+    type: multiple
+    title: Charge Bypass
+    tags: [ non-essential, ordinal ]
+    options:
+      disabled: Unset
+      awake: While On
+      always: Always
+    default: Unset

{adjustor-3.7.6 → adjustor-3.8.0}/src/adjustor/drivers/smu/__init__.py

@@ -44,8 +44,8 @@ class SmuQamPlugin(HHDPlugin):
     def __init__(
         self,
         dev: dict[str, DeviceParams],
-        pp_map: list[tuple[str, int]] | None,
-        energy_map: list[tuple[str, int]] | None,
+        pp_map: list[tuple[str, list[str], int, int]] | None,
+        pp_enable: bool = True,
         init_tdp: bool = True,
     ) -> None:
         self.name = f"adjustor_smu_qam"
@@ -80,19 +80,15 @@ class SmuQamPlugin(HHDPlugin):
         # startup
         self.init_tdp = init_tdp
 
-        self.energy_map = energy_map
-        if pp_map:
+        self.pp_map = pp_map
+        if pp_enable and pp_map:
             self.pps = get_platform_choices() or []
-            if self.pps:
-                self.pp_map = pp_map
-            else:
+            if not self.pps:
                 logger.warning(
                     f"Platform profile map was provided but device does not have platform profiles."
                 )
-                self.pp_map = None
         else:
             self.pps = []
-            self.pp_map = None
 
     def settings(self):
         if not self.enabled:
@@ -205,18 +201,16 @@ class SmuQamPlugin(HHDPlugin):
             conf["tdp.smu.std.skin_limit"] = new_tdp
             conf["tdp.smu.std.stapm_limit"] = new_tdp
 
-            if self.pp_map and conf["tdp.smu.platform_profile"].to(str) != "disabled":
-                pp = self.pp_map[0][0]
-                for npp, tdp in self.pp_map:
-                    if tdp < new_tdp and npp in self.pps:
-                        pp = npp
-                conf["tdp.smu.platform_profile"] = pp
-
-            if self.energy_map:
-                ep = self.energy_map[0][0]
-                for nep, tdp in self.energy_map:
+            if self.pp_map:
+                pp = ep = self.pp_map[0][0]
+                for nep, npps, tdp, target in self.pp_map:
                     if tdp < new_tdp:
                         ep = nep
+                        for npp in npps:
+                            if npp in self.pps:
+                                pp = npp
+                if self.pps and conf.get("tdp.smu.platform_profile", "disabled") != "disabled":
+                    conf["tdp.smu.platform_profile"] = pp
                 conf["tdp.smu.energy_policy"] = ep
 
             if new_boost:
@@ -310,15 +304,13 @@ class SmuQamPlugin(HHDPlugin):
                 self.new_tdp = ev["tdp"]
                 self.sys_tdp = ev["tdp"] is not None
 
-            if ev["type"] == "ppd":
-                # TODO: Make tunable per device
-                match ev["status"]:
-                    case "power":
-                        self.new_tdp = 8
-                    case "balanced":
-                        self.new_tdp = 15
-                    case "performance":
-                        self.new_tdp = 25
+            if ev["type"] == "ppd" and self.pp_map:
+                for ep, pps, tdp, target in self.pp_map:
+                    if ep == ev["status"]:
+                        self.new_tdp = target
+                        break
+                else:
+                    logger.warning(f"Energy profile '{ev['status']}' not found in map.")
 
             if ev["type"] == "special" and ev.get("event", None) == "wakeup":
                 logger.info(
@@ -462,6 +454,12 @@ class SmuDriverPlugin(HHDPlugin):
                 self.is_set = False
             self.old_pp = new_pp
 
+        # Inform ppd instantly to avoid lag in slider
+        new_target = conf["tdp.smu.energy_policy"].to(str)
+        if new_target != self.old_target:
+            self.old_target = new_target
+            self.emit({"type": "energy", "status": new_target})  # type: ignore
+
         if conf["tdp.smu.apply"].to(bool):
             conf["tdp.smu.apply"] = False
 
@@ -471,11 +469,6 @@ class SmuDriverPlugin(HHDPlugin):
                     set_platform_profile(cpp)
                     time.sleep(PP_DELAY)
 
-            new_target = conf["tdp.smu.energy_policy"].to(str)
-            if new_target != self.old_target:
-                self.old_target = new_target
-                self.emit({"type": "energy", "status": new_target})  # type: ignore
-
             alib(
                 new_vals,
                 self.cpu,

{adjustor-3.7.6 → adjustor-3.8.0}/src/adjustor/hhd.py

@@ -10,7 +10,7 @@ from hhd.plugins.plugin import Emitter
 from hhd.utils import expanduser
 
 from adjustor.core.acpi import check_perms, initialize
-from adjustor.core.const import CPU_DATA, DEV_DATA, PLATFORM_PROFILE_MAP, ENERGY_MAP
+from adjustor.core.const import CPU_DATA, DEV_DATA
 
 from .i18n import _
 
@@ -243,6 +243,7 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
     from .drivers.lenovo import LenovoDriverPlugin
     from .drivers.smu import SmuDriverPlugin, SmuQamPlugin
     from .drivers.amd import AmdGPUPlugin
+    from .drivers.battery import BatteryPlugin
 
     drivers = []
     with open("/sys/devices/virtual/dmi/id/product_name") as f:
@@ -261,9 +262,7 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
     max_tdp = 30
 
     legion_s = prod in LEGION_GO_S_DMIS
-    if (prod == LEGION_GO_DMI or legion_s) and not bool(
-        os.environ.get("HHD_ADJ_ALLY")
-    ):
+    if (prod == LEGION_GO_DMI or legion_s) and not bool(os.environ.get("HHD_ADJ_ALLY")):
         drivers.append(LenovoDriverPlugin(legion_s=legion_s))
         drivers_matched = True
         use_acpi_call = True
@@ -284,7 +283,7 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         drivers_matched = False
 
     if not drivers_matched and prod in DEV_DATA:
-        dev, cpu, pp_enable = DEV_DATA[prod]
+        dev, cpu, pp_enable, energy_map = DEV_DATA[prod]
 
         try:
             # Set values for the steam slider
@@ -308,8 +307,8 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         drivers.append(
             SmuQamPlugin(
                 dev,
-                PLATFORM_PROFILE_MAP if pp_enable else None,
-                ENERGY_MAP,
+                energy_map,
+                pp_enable=pp_enable,
                 init_tdp=not prod == "83E1",
             ),
         )
@@ -317,7 +316,7 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         use_acpi_call = True
 
     if not drivers_matched:
-        for name, (dev, cpu) in CPU_DATA.items():
+        for name, (dev, cpu, energy_map) in CPU_DATA.items():
             if name in cpuinfo:
                 drivers.append(
                     SmuDriverPlugin(
@@ -327,7 +326,7 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
                     )
                 )
                 drivers.append(
-                    SmuQamPlugin(dev, PLATFORM_PROFILE_MAP, ENERGY_MAP),
+                    SmuQamPlugin(dev, energy_map),
                 )
                 use_acpi_call = True
                 break
@@ -336,13 +335,14 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         from .drivers.general import GeneralPowerPlugin
 
         logger.info(f"No tdp drivers found for this device, using generic plugin.")
-        
+
         is_steamdeck = "Jupiter" in prod or "Galileo" in prod
-        return [GeneralPowerPlugin(is_steamdeck=is_steamdeck)]
+        return [GeneralPowerPlugin(is_steamdeck=is_steamdeck), BatteryPlugin()]
 
     return [
         *drivers,
         AdjustorInitPlugin(use_acpi_call=use_acpi_call),
         AdjustorPlugin(min_tdp, default_tdp, max_tdp),
+        BatteryPlugin(),
         AmdGPUPlugin(),
     ]

{adjustor-3.7.6 → adjustor-3.8.0/src/adjustor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: adjustor
-Version: 3.7.6
+Version: 3.8.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

{adjustor-3.7.6 → adjustor-3.8.0}/src/adjustor.egg-info/SOURCES.txt

@@ -32,6 +32,8 @@ src/adjustor/drivers/amd/ppd.py
 src/adjustor/drivers/amd/settings.yml
 src/adjustor/drivers/asus/__init__.py
 src/adjustor/drivers/asus/settings.yml
+src/adjustor/drivers/battery/__init__.py
+src/adjustor/drivers/battery/battery.yml
 src/adjustor/drivers/general/__init__.py
 src/adjustor/drivers/general/settings.yml
 src/adjustor/drivers/lenovo/__init__.py