adjustor 3.7.7__tar.gz → 3.8.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: adjustor
-Version: 3.7.7
+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.7 → adjustor-3.8.0}/pyproject.toml

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

{adjustor-3.7.7 → 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.7 → 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.7 → adjustor-3.8.0}/src/adjustor/hhd.py

@@ -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
@@ -338,11 +337,12 @@ def autodetect(existing: Sequence[HHDPlugin]) -> Sequence[HHDPlugin]:
         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.7 → adjustor-3.8.0/src/adjustor.egg-info}/PKG-INFO

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