.github/ISSUE_TEMPLATE/bug-report-or-feature-request.md

@@ -1,37 +0,0 @@
----
-name: Bug report or feature request
-about: Report an issue or request a feature request
-title: ''
-labels: ''
-assignees: ''
-
----
-
-### Fill out information requested in this template, without doing so issue will be ignored & closed!
-
-#### Before submitting an issue, it is strongly recommended to use the **[auto-cpufreq-genAI-chatbot](https://foolcontrol.org/?p=4903)** to get an immediate answer to your question.
-
-### Have you tried?
-
-- [Searching through existing/closed issues](https://github.com/AdnanHodzic/auto-cpufreq/issues) to see if your bug has already been already submitted? 
-- If installation failed with [auto-cpufreq-installer](https://github.com/AdnanHodzic/auto-cpufreq/#auto-cpufreq-installer),have you tried installing auto-cpufreq using [Snap package](https://github.com/AdnanHodzic/auto-cpufreq/#snap-store)?
-- Have you tried [configuring auto-cpufreq](https://github.com/AdnanHodzic/auto-cpufreq/#configuring-auto-cpufreq)?
-- Have you tried suggestions in [troubleshooting section](https://github.com/AdnanHodzic/auto-cpufreq#troubleshooting)?
-
-### Error output:
-```text
-Add/paste error output in case of failed installation or other failing component
-```
----
-
-### System information:
-
-Add/paste output of:
-
-```
-auto-cpufreq --debug
-```
-
-Also please be descriptive about the issue you're reporting, i.e: what you tried & what's the expected behaviour.
-
----

.github/ISSUE_TEMPLATE/config.yml

@@ -1 +0,0 @@
-blank_issues_enabled: false

.github/issue_template.md

@@ -0,0 +1,17 @@
+### Error output:
+```text
+Add/paste error output
+```
+---
+
+### System information:
+
+Add/paste output of:
+
+```
+auto-cpufreq --debug
+```
+
+#### Without providing requested information your issue might be ignored!
+
+---

.github/workflows/build-linux.yml

@@ -1,28 +0,0 @@
-name: Linux Build
-
-on:
-  push:
-    paths-ignore:
-      - "README.md"
-      - ".gitignore"
-      - "LICENSE"
-  pull_request:
-
-jobs:
-  build_linux:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4.1.1
-
-      - name: Install poetry
-        run: pipx install poetry
-
-      - name: "Setup Python"
-        uses: actions/setup-python@v5.0.0
-        with:
-          python-version: 3.12
-          cache: "poetry"
-
-      - name: "Install auto-cpufreq"
-        run: sudo ./auto-cpufreq-installer --install
-      

.github/workflows/build-nix.yaml

@@ -1,26 +0,0 @@
-name: Nix Flake
-
-on:
-  push:
-    paths-ignore:
-      - "README.md"
-      - ".gitignore"
-      - "LICENSE"
-  pull_request:
-
-jobs:
-  build-nix:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: "Install Nix ❄️"
-        uses: cachix/install-nix-action@v25
-
-      - name: "Nix Cache"
-        uses: DeterminateSystems/magic-nix-cache-action@v3
-
-      - name: "Build Nix Flake ❄️"
-        run: nix build
-
-      

.gitignore

@@ -110,7 +110,6 @@ venv/
 ENV/
 env.bak/
 venv.bak/
-.direnv
 
 # Spyder project settings
 .spyderproject
@@ -139,9 +138,3 @@ dmypy.json
 
 # pycharm
 .idea/
-
-# nix build
-/result
-
-# vs code 
-.vscode/

README.md

@@ -1,361 +1,93 @@
 # auto-cpufreq
-[![Linux Build](https://github.com/AdnanHodzic/auto-cpufreq/actions/workflows/build-linux.yml/badge.svg?event=push)](https://github.com/AdnanHodzic/auto-cpufreq/actions/workflows/build-linux.yml)
-[![Nix Flake](https://github.com/AdnanHodzic/auto-cpufreq/actions/workflows/build-nix.yaml/badge.svg?event=push)](https://github.com/AdnanHodzic/auto-cpufreq/actions/workflows/build-nix.yaml)
 
-Automatic CPU speed & power optimizer for Linux. Actively monitors laptop battery state, CPU usage, CPU temperature, and system load, ultimately allowing you to improve battery life without making any compromises.
+Automatic CPU speed & power optimizer for Linux based on active monitoring of laptop's battery state, CPU usage, CPU temperature and system load. Ultimately allowing you to improve battery life without making any compromises.
 
-For tl;dr folks:
+For tl;dr folks there's a: [Youtube: auto-cpufreq - tool demo](https://www.youtube.com/watch?v=QkYRpVEEIlg)
 
-[Youtube: auto-cpufreq v2.0 release & demo of all available features and options](https://www.youtube.com/watch?v=SPGpkZ0AZVU)
+[![](http://img.youtube.com/vi/QkYRpVEEIlg/0.jpg)](http://www.youtube.com/watch?v=QkYRpVEEIlg)
-
-[![](https://img.youtube.com/vi/SPGpkZ0AZVU/0.jpg)](https://www.youtube.com/watch?v=QkYRpVEEIlg)
-
-[Youtube: auto-cpufreq - tool demo](https://www.youtube.com/watch?v=QkYRpVEEIlg)
-
-[![](https://img.youtube.com/vi/QkYRpVEEIlg/0.jpg)](https://www.youtube.com/watch?v=QkYRpVEEIlg)
-
-
-If you're having a problem with auto-cpufreq, before ([submitting an issue](https://github.com/AdnanHodzic/auto-cpufreq/issues)), it is strongly recommended to use the **[auto-cpufreq-genAI-chatbot](https://foolcontrol.org/?p=4903)** to get an immediate answer to your question.
-
-[![](https://img.youtube.com/vi/a-UcwAAXOoc/0.jpg)](https://www.youtube.com/watch?v=a-UcwAAXOoc)
-
-Example of auto-cpufreq GUI (available >= v2.0)
-
-<img src="https://github.com/user-attachments/assets/4b83b67c-8c1e-4ef0-ad2d-ffc1b9dc16de" width="480" alt="Example of auto-cpufreq GUI (available >= v2.0)" />
-
-Example of `auto-cpufreq --stats` CLI output
-
-<img src="https://github.com/user-attachments/assets/9c7715c4-16b7-4a5c-86be-4c390276d9e8" width="480" alt="Example of auto-cpufreq CLI output"/>
-
-## Looking for developers and co-maintainers
-
-- If you would like to discuss anything regarding auto-cpufreq or its development, please join the [auto-cpufreq Discord server!](https://discord.gg/Sjauxtj6kH)
-- auto-cpufreq is looking for [co-maintainers & open source developers to help shape the future of the project!](https://github.com/AdnanHodzic/auto-cpufreq/discussions/312)
-
-## Index
-
-- [Why do I need auto-cpufreq?](#why-do-i-need-auto-cpufreq)
-  - [Supported architectures and devices](#supported-architectures-and-devices)
-- [Features](#features)
-- [Installing auto-cpufreq](#installing-auto-cpufreq)
-  - [auto-cpufreq-installer](#auto-cpufreq-installer)
-  - [Snap Store](#snap-store)
-  - [AUR package (Arch based distributions)](#aur-package-arch-based-distributions)
-  - [NixOS](#nixos)
-  - [For developers](#installation-development-mode-only)
-- [Post-installation](#post-installation)
-- [Configuring auto-cpufreq](#configuring-auto-cpufreq)
-  - [1: power_helper.py script (Snap package install only)](#1-power_helperpy-script-snap-package-install-only)
-  - [2: `--force` governor override](#2---force-governor-override)
-  - [3: auto-cpufreq config file](#3-auto-cpufreq-config-file)
-    - [Example config file contents](#example-config-file-contents)
-- [How to run auto-cpufreq](#how-to-run-auto-cpufreq)
-- [auto-cpufreq modes and options](#auto-cpufreq-modes-and-options)
-  - [monitor](#monitor)
-  - [live](#live)
-  - [overriding governor](#overriding-governor)
-  - [Install - auto-cpufreq daemon](#install---auto-cpufreq-daemon)
-  - [Update - auto-cpufreq update](#update---auto-cpufreq-update)
-  - [Remove - auto-cpufreq daemon](#remove---auto-cpufreq-daemon)
-  - [stats](#stats)
-  - [bluetooth_boot_off](#bluetooth_boot_off)
-  - [bluetooth_boot_on](#bluetooth_boot_on)
-- [Battery charging thresholds](#battery-charging-thresholds)
-  - [Supported Devices](#supported-devices)
-  - [Battery config](#battery-config)
-  - [Ignoring power supplies](#Ignoring-power-supplies)
-- [Troubleshooting](#troubleshooting)
-  - [AUR](#aur)
-- [Discussion](#discussion)
-- [Donate](#donate)
-  - [Financial donation](#financial-donation)
-    - [Paypal](#paypal)
-    - [BitCoin](#bitcoin)
-  - [Code contribution](#code-contribution)
 
 ## Why do I need auto-cpufreq?
 
-One of the problems with Linux today on laptops is that the CPU will run in an unoptimized manner which will negatively impact battery life. For example, the CPU may run using the "performance" governor with turbo boost enabled regardless of whether it's plugged into a power outlet or not.
+One of the problems with Linux today on laptops is that CPU will run in unoptimized manner which will negatively reflect on battery life. For example, CPU will run using "performance" governor with turbo boost enabled regardless if it's plugged in to power or not.
 
-These issues can be mitigated by using tools like [indicator-cpufreq](https://itsfoss.com/cpufreq-ubuntu/) or [cpufreq](https://github.com/konkor/cpufreq), but those still require manual action from your side which can be daunting and cumbersome.
+Issue can be mitigated by using tools like [indicator-cpufreq](https://itsfoss.com/cpufreq-ubuntu/) or [cpufreq](https://github.com/konkor/cpufreq), but these still require manual action from your side which can be daunting and cumbersome.
 
-Tools like [TLP](https://github.com/linrunner/TLP) (which I used for numerous years) can help extend battery life, but may also create their own set of problems, such as losing turbo boost.
+Using tools like [TLP](https://github.com/linrunner/TLP) can help in this situation with extending battery life (which is something I used to do for numerous years), but it also might come with its own set of problems, like losing turbo boost.
 
-Given all of the above, I needed a simple tool that would automatically make CPU frequency-related changes and save battery life, but let the Linux kernel do most of the heavy lifting. That's how auto-cpufreq was born.
+With that said, I needed a simple tool which would automatically make "cpufreq" related changes, save battery like TLP, but let Linux kernel do most of the heavy lifting. That's how auto-cpufreq was born.
 
-Please note: auto-cpufreq aims to replace TLP in terms of functionality, so after you install auto-cpufreq _it's recommended to remove TLP_. Using both for the same functionality (i.e., to set CPU frequencies) will lead to unwanted results like overheating. Hence, only use [both tools in tandem](https://github.com/AdnanHodzic/auto-cpufreq/discussions/176) if you know what you're doing.
+Please note: auto-cpufreq aims to replace TLP in terms of functionality and after you install auto-cpufreq _it's recommended to remove TLP_. If both are used for same functionality, i.e: to set CPU frequencies it'll lead to unwanted results like overheating. Hence, only use [both tools in tandem](https://github.com/AdnanHodzic/auto-cpufreq/discussions/176) if you know what you're doing.
 
-One tool/daemon that does not conflict with auto-cpufreq in any way, and is even recommended to have running alongside, is [thermald](https://wiki.debian.org/thermald).
+Tool/daemon that does not conflict with auto-cpufreq in any way and is even recommended to have running alongside is [thermald](https://wiki.debian.org/thermald). 
 
 #### Supported architectures and devices
 
-Only devices with an Intel, AMD, or ARM CPU are supported. This tool was developed to improve performance and battery life on laptops, but running it on desktops/servers (to lower power consumption) should also be possible.
+Supported devices must have an Intel, AMD or ARM CPUs. This tool was developed to improve performance and battery life on laptops, but running it on desktop/servers (to lower power consumption) should also be possible.
 
 ## Features
 
-- Monitoring
+* Monitoring
-  - Basic system information
+  * Basic system information
-  - CPU frequency (system total & per core)
+  * CPU frequency (system total & per core)
-  - CPU usage (system total & per core)
+  * CPU usage (system total & per core)
-  - CPU temperature (total average & per core)
+  * CPU temperature (total average & per core)
-  - Battery state
+  * Battery state
-  - System load
+  * System load
-- CPU frequency scaling, governor, and [turbo boost](https://en.wikipedia.org/wiki/Intel_Turbo_Boost) management based on
+* CPU frequency scaling, governor and [turbo boost](https://en.wikipedia.org/wiki/Intel_Turbo_Boost) management based on
-  - Battery state
+  * Battery state
-  - CPU usage (total & per core)
+  * CPU usage (total & per core)
-  - CPU temperature in combination with CPU utilization/load (to prevent overheating)
+  * CPU temperature in combination with CPU utilization/load (prevent overheating)
-  - System load
+  * System load
-- Automatic CPU & power optimization (temporary and persistent)
+* Automatic CPU & power optimization (temporary and persistent)
-- Settings battery charging thresholds (limited support)
 
 ## Installing auto-cpufreq
 
-### auto-cpufreq-installer
+### Snap store
 
-> As auto-cpufreq relies on git based versioning, users are advised to install `auto-cpufreq`  using `git clone` method only. Downloading source code as a zip/from release will emit build error like [these](https://github.com/AdnanHodzic/auto-cpufreq/issues/623).
+auto-cpufreq is available on [snap store](https://snapcraft.io/auto-cpufreq), or can be installed using CLI:
-
-Get source code, run installer, and follow on-screen instructions:
-
-```
-git clone https://github.com/AdnanHodzic/auto-cpufreq.git
-cd auto-cpufreq && sudo ./auto-cpufreq-installer
-```
-
-### Snap Store
-
-*Please note: while all [auto-cpufreq >= v2.0 CLI functionality](https://www.youtube.com/watch?v=SPGpkZ0AZVU&t=295s) will work as intended, [the GUI won't be available on Snap package installs](http://foolcontrol.org/wp-content/uploads/2023/10/auto-cpufreq-v2-snap-deprecation-notice.png) due to [Snap package confinement limitations](https://forum.snapcraft.io/t/pkexec-not-found-python-gtk-gnome-app/36579). Hence, please consider installing auto-cpufreq using [auto-cpufreq-installer](#auto-cpufreq-installer)*.
-
-auto-cpufreq is available on the [Snap Store](https://snapcraft.io/auto-cpufreq) or via CLI:
 
 ```
 sudo snap install auto-cpufreq
 ```
 
 **Please note:** 
-- Make sure [snapd](https://snapcraft.io/docs/installing-snapd) is installed and `snap version` is >= 2.44 for `auto-cpufreq` to fully work due to [recent snapd changes](https://github.com/snapcore/snapd/pull/8127).
+* Make sure [snapd](https://snapcraft.io/docs/installing-snapd) is installed and `snap version` version is >= 2.44 for `auto-cpufreq` to fully work due to [recent snapd changes](https://github.com/snapcore/snapd/pull/8127).
 
-- Fedora users will [encounter the following error](https://twitter.com/killyourfm/status/1291697985236144130) due to `cgroups v2` [being in development](https://github.com/snapcore/snapd/pull/7825). This problem can be resolved by either running `sudo snap run auto-cpufreq` after the snap installation or by using the [auto-cpufreq-installer](#auto-cpufreq-installer) which doesn't have this issue.
+* Fedora users will [encounter following error](https://twitter.com/killyourfm/status/1291697985236144130). Due to `cgroups v2` [being in development](https://github.com/snapcore/snapd/pull/7825). This problem can be resolved by either running `sudo snap run auto-cpufreq` after snap installation. Or using [auto-cpufreq-installer](https://github.com/AdnanHodzic/auto-cpufreq/#auto-cpufreq-installer) which doesn't have this issue.
 
-### AUR package (Arch based distributions)
+### auto-cpufreq-installer
 
-[![AUR package](https://repology.org/badge/version-for-repo/aur/auto-cpufreq.svg)](https://aur.archlinux.org/packages/auto-cpufreq)
+Get source code, run installer and follow on screen instructions:
-
-The AUR [Release Package](https://aur.archlinux.org/packages/auto-cpufreq) is currently being maintained by [MusicalArtist12](https://github.com/MusicalArtist12), [liljaylj](https://github.com/liljaylj), and [parmjotsinghrobot](https://github.com/parmjotsinghrobot). 
-
-**Notices**
-
-- The [Git Package](https://aur.archlinux.org/packages/auto-cpufreq-git) is seperately maintained and was last updated on version 1.9.6. 
-- The build process links to `/usr/share/` instead of `/usr/local/share/`
-- The daemon installer provided does not work, instead start the daemon with 
 
 ```
-# systemctl enable --now auto-cpufreq 
-```
-- The GNOME Power Profiles daemon is [automatically disabled by auto-cpufreq-installer](https://github.com/AdnanHodzic/auto-cpufreq#1-power_helperpy-script-snap-package-install-only) due to it's conflict with auto-cpufreq.service. However, this doesn't happen with AUR installs, which can lead to problems (e.g., [#463](https://github.com/AdnanHodzic/auto-cpufreq/issues/463)) if not masked manually.
-  - Open a terminal and run `sudo systemctl mask power-profiles-daemon.service` (then `enable` and `start` the auto-cpufreq.service if you haven't already).
-- The TuneD daemon(enabled by default with Fedora 41) is [automatically disabled by auto-cpufreq-installer](https://github.com/AdnanHodzic/auto-cpufreq#1-power_helperpy-script-snap-package-install-only) due to it's conflict with auto-cpufreq.service.
-
-### Gentoo Linux (GURU Repository)
-
-New versions of auto-cpufreq were recently added to GURU, Gentoo's official community-maintained ebuild repository. The [ebuild](https://github.com/gentoo-mirror/guru/tree/master/sys-power/auto-cpufreq) is maintaned by [S41G0N](https://github.com/S41G0N) and other [GURU contributors](https://bugs.gentoo.org), who can respond in case of issues.
-
-In order to build auto-cpufreq, it is necessary to add & sync GURU repository first. Adding ~amd64 keyword is also needed to unmask the package.
-
-``` 
-# echo "sys-power/auto-cpufreq ~amd64" >> /etc/portage/package.accept_keywords
-# eselect repository enable guru
-# emaint sync -r guru
-# emerge --ask auto-cpufreq
-```
-
-**Notices**
-
-- The build process links to `/usr/share/` instead of `/usr/local/share/`
-- The build works on both systemd/OpenRC systems (both systemd and OpenRC will have a service called auto-cpufreq which can be started automatically)
-- The daemon installer provided does work, but it is RECOMMENDED to install the daemon with:
-``` 
-# systemctl enable --now auto-cpufreq 
-# rc-update add auto-cpufreq default && rc-service auto-cpufreq start
-```
-
-### NixOS
-
-<details>
-<summary>Flakes</summary>
-<br>
-
-This repo contains a flake that exposes a NixOS Module that manages and offers options for auto-cpufreq. To use it, add the flake as an input to your `flake.nix` file and enable the module:
-
-```nix 
-# flake.nix
-
-{
-
-    inputs = {
-        # ---Snip---
-        auto-cpufreq = {
-            url = "github:AdnanHodzic/auto-cpufreq";
-            inputs.nixpkgs.follows = "nixpkgs";
-        };
-        # ---Snip---
-    }
-
-    outputs = {nixpkgs, auto-cpufreq, ...} @ inputs: {
-        nixosConfigurations.HOSTNAME = nixpkgs.lib.nixosSystem {
-            specialArgs = { inherit inputs; };
-            modules = [
-                ./configuration.nix
-                auto-cpufreq.nixosModules.default
-            ];
-        };
-    } 
-}
-```
-Then you can enable the program in your `configuration.nix` file:
-```nix
-# configuration.nix
-
-{inputs, pkgs, ...}: {
-    # ---Snip---
-    programs.auto-cpufreq.enable = true;
-    # optionally, you can configure your auto-cpufreq settings, if you have any
-    programs.auto-cpufreq.settings = {
-    charger = {
-      governor = "performance";
-      turbo = "auto";
-    };
-
-    battery = {
-      governor = "powersave";
-      turbo = "auto";
-    };
-  };
-    # ---Snip---
-}
-```
-</details>
-
-<details>
-<summary>Nixpkgs</summary>
-<br>
-
-There is a nixpkg available, but it is more prone to being outdated, whereas the flake pulls from the latest commit. You can install it in your `configuration.nix` and enable the system service:
-```nix
-# configuration.nix
-
-# ---Snip---
-environment.systemPackages = with pkgs; [
-    auto-cpufreq
-];
-
-services.auto-cpufreq.enable = true;
-# ---Snip---
-```
-</details>
-
-### Installation (development mode only)
-
-- If you have `poetry` installed:
-  ```bash
 git clone https://github.com/AdnanHodzic/auto-cpufreq.git
-  cd auto-cpufreq
+cd auto-cpufreq && sudo ./auto-cpufreq-installer
-  poetry install
-  poetry run auto-cpufreq --help
 ```
 
-- Alternatively, we can use an editable pip install for development purposes:
+In case you encounter any problems with `auto-cpufreq-installer`, please [submit a bug report](https://github.com/AdnanHodzic/auto-cpufreq/issues/new).
-  ```bash
-  git clone https://github.com/AdnanHodzic/auto-cpufreq.git
-  cd auto-cpufreq
-  # set up virtual environment (details removed for brevity)
-  pip3 install -e .
-  auto-cpufreq
-  ```
-- Regularly run `poetry update` if you get any inconsistent lock file issues.
 
-## Post-installation
+### AUR package (Arch/Manjaro Linux)
 
-After installation, `auto-cpufreq` is available as a binary. Refer to [auto-cpufreq modes and options](https://github.com/AdnanHodzic/auto-cpufreq#auto-cpufreq-modes-and-options) for detailed information on how to run and configure `auto-cpufreq`.
+[AUR package is available](https://aur.archlinux.org/packages/auto-cpufreq-git/) for install. After which `auto-cpufreq` will be available as a binary and you can refer to [auto-cpufreq modes and options](https://github.com/AdnanHodzic/auto-cpufreq#auto-cpufreq-modes-and-options).
+
+**Please note:** If you want to install auto-cpufreq daemon, do not run `auto-cpufreq --install` otherwise you'll run into an issue: [#91](https://github.com/AdnanHodzic/auto-cpufreq/issues/91), [#96](https://github.com/AdnanHodzic/auto-cpufreq/issues/96).
+
+Instead run `systemctl start auto-cpufreq` to start the service. Run `systemctl status auto-cpufreq` to see the status of service, and `systemctl enable auto-cpufreq` for service to persist running accross reboots. 
 
 ## Configuring auto-cpufreq
 
-auto-cpufreq makes all decisions automatically based on various factors such as CPU usage, temperature, and system load. However, it's possible to perform additional configurations:
+You can configure profiles for battery and power supply. These profiles will let you pick which governor to use and how and when turbo boost is enabled. The possible values for turbo boost behavior are always, auto and never. The default behavior is auto, which only kicks in during high load.
 
-### 1: power_helper.py script (Snap package install **only**)
+Default location where config needs to be placed for it to be read automatically: `/etc/auto-cpufreq.conf`
 
-When installing auto-cpufreq via [auto-cpufreq-installer](#auto-cpufreq-installer), if it detects the [GNOME Power Profiles service](https://twitter.com/fooctrl/status/1467469508373884933) is running, it will automatically disable it. Otherwise, that daemon will cause conflicts and various other performance issues. 
+### Example config contents
-
+```
-However, when auto-cpufreq is installed as a Snap package it's running as part of a container with limited permissions, hence it's *highly recommended* to disable the GNOME Power Profiles daemon using the `power_helper.py` script.
-
-**Please Note:**<br>
-The [`power_helper.py`](https://github.com/AdnanHodzic/auto-cpufreq/blob/master/auto_cpufreq/power_helper.py) script is located within the auto-cpufreq repo at `auto_cpufreq/power_helper.py`. In order to access it, first clone
-the repository:
-
-`git clone https://github.com/AdnanHodzic/auto-cpufreq`
-
-Make sure to have `psutil` & `pyinotify` Python library installed before next step:
-
-If you're using Debian based distro install them by running:
-
-`sudo apt install python3-psutil python3-pyinotify` 
-
-or manually using pip, e.g: 
-
-`sudo pip3 install psutil pyinotify --break-system-packages`
-
-Then disable the GNOME Power Profiles daemon:
-
-`sudo python3 -m auto_cpufreq.power_helper --gnome_power_disable`
-
-for full list of options run --help, e.g:
-
-`sudo python3 -m auto_cpufreq.power_helper --help`
-
-### 2: `--force` governor override
-
-By default, auto-cpufreq uses `balanced` mode which works best for many systems and situations.
-
-However, you can override this behaviour by switching to `performance` or `powersave` mode manually. The `performance` mode results in higher default frequencies, but also higher energy use (battery consumption) and should only be used if maximum performance is needed. The `powersave` mode does the opposite and extends battery life to its maximum.
-
-See [`--force` flag](#overriding-governor) for more info.
-
-### 3: auto-cpufreq config file
-
-You can configure separate profiles for the battery and power supply. These profiles will let you pick which governor to use, as well as how and when turbo boost is enabled. The possible values for turbo boost behavior are `always`, `auto`, and `never`. The default behavior is `auto`, which only activates turbo during high load.
-
-By default, auto-cpufreq does not use a config file. If you wish to configure auto-cpufreq statically, we look for a configuration file in the following order:
-
-1. Commandline argument: `--config <FILE>` if passed as commandline argument to `auto-cpufreq`
-2. User-specific configuration: `$XDG_CONFIG_HOME/auto-cpufreq/auto-cpufreq.conf`
-3. System-wide configuration: `/etc/auto-cpufreq.conf`
-
-#### Example config file contents
-```python
 # settings for when connected to a power source
 [charger]
 # see available governors by running: cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors
-# preferred governor
+# preferred governor.
 governor = performance
 
-# EPP: see available preferences by running: cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_available_preferences
-energy_performance_preference = performance
-
-# EPB (Energy Performance Bias) for the intel_pstate driver
-# see conversion info: https://www.kernel.org/doc/html/latest/admin-guide/pm/intel_epb.html
-# available EPB options include a numeric value between 0-15
-# (where 0 = maximum performance and 15 = maximum power saving),
-# or one of the following strings:
-# performance (0), balance_performance (4), default (6), balance_power (8), or power (15)
-# if the parameter is missing in the config and the hardware supports this setting, the default value will be used
-# the default value is `balance_performance` (for charger)
-# energy_perf_bias = balance_performance
-
-# Platform Profiles
-# https://www.kernel.org/doc/html/latest/userspace-api/sysfs-platform_profile.html
-# See available options by running:
-# cat /sys/firmware/acpi/platform_profile_choices
-# platform_profile = performance
-
 # minimum cpu frequency (in kHz)
 # example: for 800 MHz = 800000 kHz --> scaling_min_freq = 800000
 # see conversion info: https://www.rapidtables.com/convert/frequency/mhz-to-hz.html
@@ -377,25 +109,6 @@ turbo = auto
 # preferred governor
 governor = powersave
 
-# EPP: see available preferences by running: cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_available_preferences
-energy_performance_preference = power
-
-# EPB (Energy Performance Bias) for the intel_pstate driver
-# see conversion info: https://www.kernel.org/doc/html/latest/admin-guide/pm/intel_epb.html
-# available EPB options include a numeric value between 0-15
-# (where 0 = maximum performance and 15 = maximum power saving),
-# or one of the following strings:
-# performance (0), balance_performance (4), default (6), balance_power (8), or power (15)
-# if the parameter is missing in the config and the hardware supports this setting, the default value will be used
-# the default value is `balance_power` (for battery)
-# energy_perf_bias = balance_power
-
-# Platform Profiles
-# https://www.kernel.org/doc/html/latest/userspace-api/sysfs-platform_profile.html
-# See available options by running:
-# cat /sys/firmware/acpi/platform_profile_choices
-# platform_profile = low-power
-
 # minimum cpu frequency (in kHz)
 # example: for 800 MHz = 800000 kHz --> scaling_min_freq = 800000
 # see conversion info: https://www.rapidtables.com/convert/frequency/mhz-to-hz.html
@@ -408,68 +121,15 @@ energy_performance_preference = power
 # to use this feature, uncomment the following line and set the value accordingly
 # scaling_max_freq = 1000000
 
-# turbo boost setting (always, auto, or never)
+# turbo boost setting. possible values: always, auto, never
 turbo = auto
-
-# battery charging threshold
-# reference: https://github.com/AdnanHodzic/auto-cpufreq/#battery-charging-thresholds
-#enable_thresholds = true
-#start_threshold = 20
-#stop_threshold = 80
 ```
 
 ## How to run auto-cpufreq
-auto-cpufreq should be run with with one of the following options:
 
-- [monitor](#monitor)
+auto-cpufreq can be run by simply running the `auto-cpufreq` and following on screen instructions, i.e:
-  - Monitor and see suggestions for CPU optimizations
 
-- [live](#live)
+`sudo auto-cpufreq`
-  - Monitor and automatically make (temporary) CPU optimizations
-
-- [install](#install---auto-cpufreq-daemon) / [remove](#remove---auto-cpufreq-daemon)
-  - Install/remove daemon for (permanent) automatic CPU optimizations
- 
-- [install (GUI)](#install---auto-cpufreq-daemon)
-  - Install daemon via GUI for (permanent) automatic CPU optimizations
-
-- [update](#update---auto-cpufreq-update)
-  - Update auto-cpufreq to the latest release
-
-- [install_performance](#1-power_helperpy-script)
-  - Install daemon in "performance" mode
-
-- [stats](#stats)
-  - View live stats of CPU optimizations made by daemon
-
-- [bluetooth_boot_off](#bluetooth_boot_off)
-  - Turn off Bluetooth on boot (only)! Can be turned on any time later on.
-
-- [bluetooth_boot_on](#bluetooth_boot_on)
-  - Turn on Bluetooth on boot.
-
-- [force=TEXT](#overriding-governor)
-  - Force use of either the "powersave" or "performance" governor, or set to "reset" to go back to normal mode
-
-- config=TEXT
-  - Use config file at designated path
-
-- debug
-  - Show debug info (include when submitting bugs)
-
-- version
-  - Show currently installed version
-
-- [donate](#financial-donation)
-  - To support the project
-
-- help
-  - Shows all of the above options
-
-- completions=TEXT
-  - To support shell completions (current options are "bash", "zsh", or "fish")
-
-Running `auto-cpufreq --help` will print the same list of options as above. Read [auto-cpufreq modes and options](#auto-cpufreq-modes-and-options) for more details.
 
 ## auto-cpufreq modes and options
 
@@ -477,262 +137,74 @@ Running `auto-cpufreq --help` will print the same list of options as above. Read
 
 `sudo auto-cpufreq --monitor`
 
-No changes are made to the system. This is solely to demonstrate what auto-cpufreq could do for your system.
+No changes are made to the system, and is solely made for demonstration purposes what auto-cpufreq could do differently for your system.
 
 ### Live
 
 `sudo auto-cpufreq --live`
 
-Necessary changes are temporarily made to the system over time, but this process and its changes are lost at system reboot. This mode is provided to evaluate how the system would behave with auto-cpufreq permanently running on the system.
+Necessary changes are temporarily made to the system which are lost with system reboot. This mode is made to evaluate what the system would behave with auto-cpufreq permanently running on the system.
-
-### Overriding governor
-
-`sudo auto-cpufreq --force=governor`
-
-Force use of either the "powersave" or "performance" governor, or set to "reset" to go back to normal mode.
-Please note that any set override will persist even after reboot.
 
 ### Install - auto-cpufreq daemon
 
-Necessary changes are made to the system over time and this process will continue across reboots. The daemon is deployed and started as a systemd service. Changes are made automatically and live stats are generated for monitoring purposes.
+Necessary changes are made to the system for auto-cpufreq CPU optimizaton to persist across reboots. Daemon is deployed and then started as a systemd service. Changes are made automatically and live stats are generated for monitoring purposes.
-
-**Install the daemon using CLI ([after installing auto-cpufreq](#installing-auto-cpufreq)):**
-
-Installing the auto-cpufreq daemon using CLI is as simple as running the following command:
 
 `sudo auto-cpufreq --install`
 
-After the daemon is installed, `auto-cpufreq` is available as a binary and runs in the background. Its stats can be viewed by running: `auto-cpufreq --stats`
+After daemon is installed, `auto-cpufreq` is available as a binary and is running in the background. Its stats can be viewed by running: `auto-cpufreq --stats`
 
-*Please note:* if the daemon is installed within a desktop environment, then its stats and options can be accessed via CLI or GUI. See "Install the daemon using GUI" below for more details.
+Since daemon is running as a systemd service, its status can be seen by running:
-
-**Install the daemon using GUI**
-
-Starting with >= v2.0 [after installing auto-cpufreq](#installing-auto-cpufreq), an auto-cpufreq desktop entry (icon) is available, i.e.:
-
-<img src="https://github.com/user-attachments/assets/f426d62b-00b0-4fa5-a72e-b352016ed448" width="640" alt="Example of auto-cpufreq desktop entry (icon)"/>
-
-After selecting it to open the GUI, the auto-cpufreq daemon can be installed by clicking the "Install" button:
-
-<img src="https://github.com/user-attachments/assets/5af47e5e-8b9e-4ff6-9ffc-e78acb623ce4" width="480" alt="The auto-cpufreq GUI's 'Install' button"/>
-
-After that, the full auto-cpufreq GUI is available:
-
-<img src="https://github.com/user-attachments/assets/9c7715c4-16b7-4a5c-86be-4c390276d9e8" width="640" alt="The full auto-cpufreq GUI"/>
-
-*Please note:* after the daemon is installed (by any method), its stats and options are accessible via both CLI and GUI.
-
-**auto-cpufreq daemon service**
-
-Installing the auto-cpufreq daemon also enables the associated service (equivalent to `systemctl enable auto-cpufreq`), causing it to start on boot, and immediately starts it (equivalent to `systemctl start auto-cpufreq`).
-
-Since the daemon is running as a systemd service, its status can be seen by running:
 
 `systemctl status auto-cpufreq`
 
-If installed via Snap package, daemon status can be viewed as follows:
+If install has been performed as part of snap package, daemon status can be verified by running: 
 
 `systemctl status snap.auto-cpufreq.service.service`
 
-### Update - auto-cpufreq update
-
-Update functionality works by cloning the auto-cpufreq repo, installing it via [auto-cpufreq-installer](#auto-cpufreq-installer), and performing a fresh [auto-cpufreq daemon install](#install---auto-cpufreq-daemon) to provide the [latest version's](https://github.com/AdnanHodzic/auto-cpufreq/releases) changes.
-
-Update auto-cpufreq by running: `sudo auto-cpufreq --update`. By default, the latest revision is cloned to `/opt/auto-cpufreq/source`, thus maintaining existing directory structure.
-
-Update and clone to a custom directory by running: `sudo auto-cpufreq --update=/path/to/directory`
-
 ### Remove - auto-cpufreq daemon
 
-The auto-cpufreq daemon, its systemd service, and all its persistent changes can be removed by running:
+auto-cpufreq daemon and its systemd service, along with all its persistent changes can be removed by running:
 
 `sudo auto-cpufreq --remove`
 
-This does, in part, the equivalent of `systemctl stop auto-cpufreq && systemctl disable auto-cpufreq`, but the above command should be used instead of using `systemctl`.
-
-*Please note:* after the daemon is removed, the auto-cpufreq GUI and desktop entry (icon) are also removed.
-
 ### Stats
 
-If the daemon has been installed, live stats of CPU/system load monitoring and optimization can be seen by running:
+If daemon has been installed, live stats of CPU/system load monitoring and optimization can be seen by running:
 
 `auto-cpufreq --stats`
 
-### bluetooth_boot_off
-
-Turn off Bluetooth on boot (only)! Bluetooth can still be turned on manually when needed. This option is executed during the installation of the auto-cpufreq daemon, but it can also be run independently without installing the daemon.
-
-It prevents GNOME from automatically enabling Bluetooth on every reboot or after suspend/wake up even if you manually disable it, GNOME will turn it back on unless this option is used.
-
-### bluetooth_boot_on
-
-Useful if you prefer Bluetooth to be enabled at boot time, especially after installing the auto-cpufreq daemon, which will disable it by default.
-
-## Battery charging thresholds
-
-***Please note:** [Original implementor](https://github.com/AdnanHodzic/auto-cpufreq/pull/637) is looking for user input & testing to further improve this functionality. If you would like to help in this process, please refer to [Looking for developers and co-maintainers](https://github.com/AdnanHodzic/auto-cpufreq/#looking-for-developers-and-co-maintainers)*.
-
-As of [v2.2.0](https://github.com/AdnanHodzic/auto-cpufreq/releases/tag/v2.2.0), battery charging thresholds can be set in the config file. This enforces your battery to start and stop charging at defined values.
-
-### Supported devices
-
-- **Lenovo ThinkPad** (thinkpad_acpi)*
-- **Lenovo IdeaPad** (ideapad_acpi)*
-
-***Please note, your laptop must have an installed ACPI kernel driver specific to the manufacturer.** To check if you have the correct module installed and loaded run `lsmod [module]`
-
-**To request that your device be supported, please open an [issue](https://github.com/AdnanHodzic/auto-cpufreq/issues/new). In your issue, make us aware of the driver that works with your laptop**
-
-### Battery config
-Edit the config at `/etc/auto-cpufreq.conf`
-
-Example config for battery ([already part of example config file](https://github.com/AdnanHodzic/auto-cpufreq/#example-config-file-contents))
-```
-[battery]
-enable_thresholds = true
-start_threshold = 20
-stop_threshold = 80
-```
-
-### Lenovo_laptop conservation mode
-
-this works only with `lenovo_laptop` kernel module compatable laptops.  
-
-add `ideapad_laptop_conservation_mode = true` to your `auto-cpufreq.conf` file
-
-### Special cases of Lenovo_ideapad (or some other models with fixed threshold)
-
-As you may know, for some laptop models you can only decide to limit battery charging but can not set the limit value. The limit value is set by the manufacturer in the system (generally 60% and sometimes 80%). Also, you can not set the value of start charging.
-
-This limit value is not always accessible for users to avoid changing it, but you can try looking in some of these paths : 
-
-```
-cat /sys/bus/platform/drivers/ideapad_acpi/VPC2004:00/charge_control_end_threshold
-cat /sys/class/power_supply/BAT0/charge_control_end_threshold
-cat /sys/class/power_supply/BAT0/charge_control_start_threshold
-```
-
-This is the config to apply at /etc/auto-cpufreq.conf in order to stop battery charging at 60% or 80% depending on the value set in the system by the manufacturer.
-
-```
-[battery]
-enable_thresholds = true
-start_threshold = 20
-stop_threshold = 1
-
-```
-start_threshold = 20 (should be present with a valid number but it's ignored)
-
-stop_threshold = 1 (to stop charging the battery at the limit value 60% or 80%)
-
-### Ignoring power supplies
-
-you may have a controler or headphones and when ever they may be on battery they might cause auto-cpufreq
-to limit preformence to ignore them add to you config file the name of the power supply, under `[power_supply_ignore_list]`
-
-the name of the power supply can be found with  `ls /sys/class/power_supply/`
-
-```
-[power_supply_ignore_list]
-
-name1 = this
-name2 = is 
-name3 = an
-name4 = example
-
-# like this
-xboxctrl = {the xbox controler power supply name}
-
-```
-
 ## Troubleshooting
 
 **Q:** If after installing auto-cpufreq you're (still) experiencing:
-- high CPU temperatures
+* high CPU temperatures
-- CPU not scaling to minimum/maximum frequencies
+* CPU is not scaling to minimum/maximum frequencies
-- suboptimal CPU performance
+* suboptimal CPU peformance
-- turbo mode not available
 
-**A:** If you're using the `intel_pstate/amd-pstate` CPU management driver, consider changing it to `acpi-cpufreq`.
+**A:** If you're using `intel_pstate` CPU management driver consider changing it to: `acpi-cpufreq`.
 
-This can be done by editing the `GRUB_CMDLINE_LINUX_DEFAULT` params in `/etc/default/grub`. For instance:
+This can be done by editting `/etc/default/grub` file and appending `intel_pstate=disable` to `GRUB_CMDLINE_LINUX_DEFAULT` line, followed by `sudo update-grub`
 
-```
+Example line change:
-    sudo nano /etc/default/grub
-    # make sure you have nano installed, or you can use your favorite text editor
-```
-
-For Intel users:
 
 ```
 GRUB_CMDLINE_LINUX_DEFAULT="quiet splash intel_pstate=disable"
 ```
 
-For AMD users:
-
-```
-GRUB_CMDLINE_LINUX_DEFAULT="quiet splash initcall_blacklist=amd_pstate_init amd_pstate.enable=0"
-```
-
-Once you have made the necessary changes to the GRUB configuration file, you can update GRUB by running `sudo update-grub` on Debian/Ubuntu, `sudo grub-mkconfig -o /boot/grub/grub.cfg` on Arch Linux, or one of the following on Fedora:
-
-```
-    sudo grub2-mkconfig -o /etc/grub2.cfg
-```
-
-```
-    sudo grub2-mkconfig -o /etc/grub2-efi.cfg
-```
-
-```
-    sudo grub2-mkconfig -o /boot/grub2/grub.cfg
-    # legacy boot method
-```
-
-For systemd-boot users:
-
-```
-    sudo nano /etc/kernel/cmdline
-    # make sure you have nano installed, or you can use your favorite text editor
-```
-
-For Intel users:
-
-```
-quiet splash intel_pstate=disable
-```
-
-For AMD users:
-
-```
-quiet splash initcall_blacklist=amd_pstate_init amd_pstate.enable=0
-```
-
-Once you have made the necessary changes to the `cmdline` file, you can update it by running `sudo reinstall-kernels`.
-
-### AUR
-
-- If the AUR installer does not work for your system, fallback to `auto-cpufreq-installer` and open an issue. 
-
 ## Discussion:
 
-- Blogpost: [auto-cpufreq - Automatic CPU speed & power optimizer for Linux](http://foolcontrol.org/?p=3124)
+* Blogpost: [auto-cpufreq - Automatic CPU speed & power optimizer for Linux](http://foolcontrol.org/?p=3124)
 
 ## Donate
 
-Showing your support and appreciation for the auto-cpufreq project can be done in two ways:
+Showing your support and appreciation for auto-cpufreq project can be done in two ways:
 
-- Financial donation
+* Financial donation
-- Code contribution
+* Code contribution
 
 ### Financial donation
 
 If auto-cpufreq helped you out and you find it useful, show your appreciation by donating (any amount) to the project!
 
-##### Become Github Sponsor
-
-[Become a sponsor to Adnan Hodzic on Github](https://github.com/sponsors/AdnanHodzic) to acknowledge my efforts and help project's further open source development.
-
 ##### PayPal
 [![paypal](https://www.paypalobjects.com/en_US/NL/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=7AHCP5PU95S4Y&item_name=Contribution+for+work+on+auto-cpufreq&currency_code=EUR&source=url)
 
@@ -743,6 +215,6 @@ If auto-cpufreq helped you out and you find it useful, show your appreciation by
 
 ### Code contribution
 
-Other ways of supporting the project consist of making a code or documentation contribution. If you have an idea for a new feature or you want to implement some of the existing feature requests or fix some of the [bugs & issues](https://github.com/AdnanHodzic/auto-cpufreq/issues), please make your changes and submit a [pull request](https://github.com/AdnanHodzic/auto-cpufreq/pulls). I'll be glad to review it and, if your changes are accepted, you'll be credited on the [releases page](https://github.com/AdnanHodzic/auto-cpufreq/releases).
+Other ways of supporting the project consists of making a code or documentation contribution. If you have an idea for a new features or want to implement some of the existing feature requests or fix some of the [bugs & issues](https://github.com/AdnanHodzic/auto-cpufreq/issues). Please make your changes and submit a [pull request](https://github.com/AdnanHodzic/auto-cpufreq/pulls) which I'll be glad to review. If your changes are accepted you'll be credited as part of [releases page](https://github.com/AdnanHodzic/auto-cpufreq/releases).
 
-**Please note: auto-cpufreq is looking for co-maintainers & open source developers to [help shape the future of the project!](https://github.com/AdnanHodzic/auto-cpufreq/discussions/312)**
+**Please note: auto-cpufreq is looking for co-maintainers & open source developers to [help shape future of the project!](https://github.com/AdnanHodzic/auto-cpufreq/discussions/312)**

auto-cpufreq-installer

@@ -1,268 +1,252 @@
-#!/usr/bin/env bash
+#!/bin/bash
 
 # auto-cpufreq-installer:
 # auto-cpufreq source code based installer
 
-cd "$(dirname "$(readlink -f "$0")")" || exit 1
+SCRIPT_PATH=$(readlink -f "$0")
+SCRIPT_DIR=$(dirname "${SCRIPT_PATH}")
+cd "${SCRIPT_DIR}"
 
-COLOUMNS="`tput cols`"
+# check if lsb_release exists on the system before using it
-MID="$((COLOUMNS / 2))"
+if command -v lsb_release > /dev/null
-
+then
-APPLICATIONS_PATH="/usr/share/applications"
-VENV_PATH="/opt/auto-cpufreq"
-
-SHARE_DIR="/usr/local/share/auto-cpufreq/"
-
-AUTO_CPUFREQ_FILE="/usr/local/bin/auto-cpufreq"
-AUTO_CPUFREQ_GTK_FILE=$AUTO_CPUFREQ_FILE-gtk
-AUTO_CPUFREQ_GTK_DESKTOP_FILE="$(basename $AUTO_CPUFREQ_GTK_FILE).desktop"
-
-IMG_FILE="/usr/share/pixmaps/auto-cpufreq.png"
-ORG_FILE="/usr/share/polkit-1/actions/org.auto-cpufreq.pkexec.policy"
-
-function header {
-  echo
-	printf "%0.s─" $(seq $((MID-(${#1}/2)-2)))
-	printf " $1 "
-	printf "%0.s─" $(seq $((MID-(${#1}/2)-2)))
-	echo; echo
-}
-
-function ask_operation {
-	header "auto-cpufreq installer"
-  echo "Welcome to auto-cpufreq tool installer."; echo
-  read -p "Select a key [I]nstall/[R]emove or press ctrl+c to quit: " answer
-}
-
-function manual_install {
-  if command -v lsb_release > /dev/null; then
   distro="$(lsb_release -is)"
   release="$(lsb_release -rs)"
   codename="$(lsb_release -cs)"
 fi
 
-	echo "Didn't detect Debian or RedHat or Arch based distro."; echo
+sep="\n-------------------------------------------------------------------------------"
-  echo "To complete installation, you need to:"
-  echo "Install: python3, pip3, python3-setuptools, gobject-introspection, cairo (or cairo-devel), gcc, and gtk3"; echo
-  echo "Install necessary Python packages:"
-  echo "pip3 install psutil click distro power requests PyGObject"
-  echo "Run following sequence of lines:"; echo
-  echo "-----"; echo
-  echo "pip3 install ."
-  echo "mkdir -p $SHARE_DIR"
-  echo "cp -r scripts/ $SHARE_DIR"; echo
-  echo "-----"; echo
-  echo "After which tool is installed, for full list of options run:";echo
-  echo "auto-cpufreq --help"
 
-  echo; printf "%0.s─" $(seq $COLOUMNS); echo
+# functions
-  
-  echo "Consider creating a feature request to add support for your distro:"
-  echo "https://github.com/AdnanHodzic/auto-cpufreq/issues/new"; echo
-  echo "Make sure to include following information:"; echo
-  echo "Distribution: $distro"
-  echo "Release: $release"
-  echo "Codename: $codename"
-  echo
 
+#separator
+function separator {
+  echo -e $sep
+}
+# root check
+function root_check {
+  if ((EUID != 0)); then
+    separator
+    echo -e "\nMust be run as root (i.e: 'sudo $0')."
+    separator
     exit 1
+  fi
+}
+
+# python packages install
+function setup_venv {
+    venv_dir=/opt/auto-cpufreq/venv
+    mkdir -p "${venv_dir}"
+    python3 -m venv "${venv_dir}"
+
+    source "${venv_dir}/bin/activate"
+    python3 -m pip install --upgrade pip
+    python3 -m pip install -r requirements.txt
+}
+
+# tool install
+function install {
+  python3 setup.py install --record files.txt
+  mkdir -p /usr/local/share/auto-cpufreq/
+  cp -r scripts/ /usr/local/share/auto-cpufreq/
+
+  # this is necessary since we need this script before we can run auto-cpufreq itself
+  cp scripts/auto-cpufreq-venv-wrapper /usr/local/bin/auto-cpufreq
+  chmod a+x /usr/local/bin/auto-cpufreq
+}
+
+# First argument is the distro
+function detected_distro() {
+  echo -e "\nDetected $1 distribution"
+  separator
+  echo -e "\nSetting up Python environment\n"
+}
+
+# merged functions pip - install - complete_msg, since it repeats
+function completed () {
+  echo -e "\nInstalling necessary Python packages\n"
+  setup_venv
+  separator
+  echo -e "\ninstalling auto-cpufreq tool\n"
+  install
+}
+
+function complete_msg() {
+  separator
+  echo -e "\nauto-cpufreq tool successfully installed.\n"
+  echo -e "For list of options, run:\nauto-cpufreq"
+  separator
+}
+
+function manual_install {
+  echo -e "\nDidn't detect Debian or RedHat based distro.\n"
+  echo -e "To complete installation, you need to:"
+  echo -e "Install: python3, pip3, python3-setuptools\n"
+  echo -e "Install necessary Python packages:"
+  echo -e "pip3 install psutil click distro power"
+  echo -e "\nRun following sequence of lines:"
+  echo -e "\n-----"
+  echo -e "\npython3 setup.py install --record files.txt"
+  echo -e "mkdir -p /usr/local/share/auto-cpufreq/"
+  echo -e "cp -r scripts/ /usr/local/share/auto-cpufreq/"
+  echo -e "\n-----"
+  echo -e "\nAfter which tool is installed, for full list of options run:"
+  echo -e "auto-cpufreq"
+  separator
+  echo -e "\nConsider creating a feature request to add support for your distro:"
+  echo -e "https://github.com/AdnanHodzic/auto-cpufreq/issues/new"
+  echo -e "\nMake sure to include following information:\n"
+  echo -e "Distribution: $distro"
+  echo -e "Release: $release"
+  echo -e "Codename: $codename"
+  separator
 }
 
 function tool_install {
-  echo
+separator
-  # First argument is the distro
-  function detected_distro {
-    header "Detected $1 distribution"
-    header "Setting up Python environment"
-  }
-
 if [ -f /etc/debian_version ]; then
 	detected_distro "Debian based"
-    VERSION=$(cat /etc/debian_version) 
+	apt install python3-dev python3-pip python3-venv python3-setuptools dmidecode -y
-
+	completed
-    # install necessary libgirepository debian package dependencies
+	complete_msg
-    # https://github.com/AdnanHodzic/auto-cpufreq/pull/826#issuecomment-2794549837
-    apt update
-
-    if apt-cache show libgirepository-2.0-dev > /dev/null 2>&1; then
-        LIB_GI_REPO="libgirepository-2.0-dev"
-        PYGOBJECT_VER="^3.50.0"
-    else
-        LIB_GI_REPO="libgirepository1.0-dev"
-        # pin PYGOBJECT_VER to libgirepository1.0-dev
-        # https://github.com/AdnanHodzic/auto-cpufreq/issues/813#issuecomment-2712543486
-        PYGOBJECT_VER="3.50.0"
-    fi
-
-    # Update PyGObject in pyproject.toml
-    # https://github.com/AdnanHodzic/auto-cpufreq/pull/826#issuecomment-2794549837
-    if [ -f ./pyproject.toml ]; then
-        if grep -q 'PyGObject *= *{[^}]*version *= *"' pyproject.toml; then
-            sed -i "s/\(PyGObject *= *{[^}]*version *= *\"\)[^\"]*\(.*\)/\1$PYGOBJECT_VER\2/" pyproject.toml
-            echo "PyGObject version updated to $PYGOBJECT_VER in pyproject.toml"
-        else
-            echo "Warning: Could not find PyGObject version entry in pyproject.toml!"
-        fi
-    else
-        echo "Error: pyproject.toml not found and PyGObject version not updated!"
-    fi
-
-
-    echo "$LIB_GI_REPO needs to be installed for version $VERSION"
-    echo '---- '
-    apt install -y python3-dev python3-pip python3-venv python3-setuptools dmidecode \
-    "$LIB_GI_REPO" libcairo2-dev libgtk-3-dev gcc
-
 elif [ -f /etc/redhat-release ]; then
 	detected_distro "RedHat based"
-    if [ -f /etc/centos-release ]; then yum install platform-python-devel
+	if [ -f /etc/centos-release ]; then
-    else yum install python-devel
+		yum install platform-python-devel dmidecode
+	else
+		yum install python-devel dmidecode
 	fi
-    yum install dmidecode gcc cairo-devel gobject-introspection-devel cairo-gobject-devel gtk3-devel
+	completed
-
+	complete_msg
 elif [ -f /etc/solus-release ]; then
 	detected_distro "Solus"
-    eopkg install pip python3 python3-devel dmidecode gobject-introspection-devel libcairo-devel gcc libgtk-3
+	eopkg install pip python3 python3-devel dmidecode
 	eopkg install -c system.devel
-
+	completed
-  elif [ -f /etc/arch-release ]; then
+ 	complete_msg
-    detected_distro "Arch Linux based"
-    pacman -S --noconfirm --needed python python-pip python-setuptools base-devel dmidecode gobject-introspection gtk3 gcc
-    
 elif [ -f /etc/os-release ];then
-    . /etc/os-release
+	eval "$(cat /etc/os-release)"
+	separator
 	case $ID in
 	opensuse-leap)
 		detected_distro "OpenSUSE"
-        zypper install -y python3 python3-pip python311-setuptools python3-devel gcc dmidecode gobject-introspection-devel python3-cairo-devel gtk3 gtk3-devel
+		zypper install -y python3 python3-pip python3-setuptools python3-devel gcc dmidecode
+		completed
 		;;
-      opensuse-tumbleweed)
+	opensuse)
 		detected_distro "OpenSUSE"
-        zypper install -y python3 python3-pip python311-setuptools python3-devel gcc dmidecode gobject-introspection-devel python3-cairo-devel gtk3 gtk3-devel
+    		echo -e "\nDetected an OpenSUSE ditribution\n\nSetting up Python environment\n"
+		zypper install -y python38 python3-pip python3-setuptools python3-devel gcc dmidecode
+		completed
+		;;
+	arch|manjaro|endeavouros|garuda|artix)
+		detected_distro "Arch Linux based"
+		pacman -S --noconfirm --needed python python-pip python-setuptools base-devel dmidecode
+		completed
 		;;
 	void)
 		detected_distro "Void Linux"
-        xbps-install -Sy python3 python3-pip python3-devel python3-setuptools base-devel dmidecode cairo-devel gobject-introspection gcc gtk+3
+    		xbps-install -Sy python3 python3-pip python3-devel python3-setuptools base-devel dmidecode
+		completed
 		;;
-      nixos)
+	*) #Any other distro
-        echo "NixOS detected"
+	manual_install
-        echo "This installer is not supported on NixOS."
+	completed
-        echo "Please refer to the install instructions for NixOS at https://github.com/AdnanHodzic/auto-cpufreq#nixos"
-        exit 1
 		;;
-      *) manual_install;;
 	esac
+ 	complete_msg
 else # In case /etc/os-release doesn't exist
 	manual_install
 fi
-
-  header "Installing necessary Python packages"
-
-  venv_dir=$VENV_PATH/venv
-  mkdir -p "$venv_dir"
-  python3 -m venv "$venv_dir"
-
-  source "$venv_dir/bin/activate"
-  python3 -m pip install --upgrade pip wheel
-
-
-  # debian specific PyGObject Installation
-  if [ -f /etc/debian_version ]; then  
-    VERSION=$(cat /etc/debian_version | cut -d'.' -f1)  
-
-    if [[ "$VERSION" =~ ^12(\.[0-9]+)?$ ]]; then 
-        python3 -m pip install PyGObject==3.50.0
-    fi
-  fi
-  python3 -m pip install PyGObject
-
-  header "Installing auto-cpufreq tool"
-  
-  git config --global --add safe.directory $(pwd)
-  python -m pip install .
-
-  mkdir -p $SHARE_DIR
-  cp -r scripts/ $SHARE_DIR
-  cp -r images/ $SHARE_DIR
-  cp images/icon.png $IMG_FILE
-  cp scripts/$(basename $ORG_FILE) $(dirname $ORG_FILE)
-
-  # this is necessary since we need this script before we can run auto-cpufreq itself
-  cp scripts/auto-cpufreq-venv-wrapper $AUTO_CPUFREQ_FILE
-  chmod a+x $AUTO_CPUFREQ_FILE
-  cp scripts/start_app $AUTO_CPUFREQ_GTK_FILE
-  chmod a+x $AUTO_CPUFREQ_GTK_FILE
-
-  desktop-file-install --dir=$APPLICATIONS_PATH scripts/$AUTO_CPUFREQ_GTK_DESKTOP_FILE
-  update-desktop-database $APPLICATIONS_PATH
-  
-  header "auto-cpufreq tool successfully installed"
-  echo "For list of options, run:"
-  echo "auto-cpufreq --help"; echo
 }
 
 function tool_remove {
+  files="files.txt"
+  share_dir="/usr/local/share/auto-cpufreq/"
+  srv_install="/usr/bin/auto-cpufreq-install"
+  srv_remove="/usr/bin/auto-cpufreq-remove"
+  stats_file="/var/run/auto-cpufreq.stats"
+  tool_proc_rm="/usr/local/bin/auto-cpufreq --remove"
+  wrapper_script="/usr/local/bin/auto-cpufreq"
+  unit_file="/etc/systemd/system/auto-cpufreq.service"
+  venv_path="/opt/auto-cpufreq"
+  cpufreqctl="/usr/bin/cpufreqctl.auto-cpufreq"
+
   # stop any running auto-cpufreq argument (daemon/live/monitor)
   tool_arg_pids=($(pgrep -f "auto-cpufreq --"))
-  for pid in "${tool_arg_pids[@]}"; do [ $pid != $$ ] && kill "$pid"; done
+  for pid in "${tool_arg_pids[@]}"; do
-
+    if [[ $tool_arg_pids != $$ ]]; then
-  function remove_directory {
+      kill "$tool_arg_pids"
-    [ -d $1 ] && rm -rf $1
+    fi
-  }
+  done
-  function remove_file {
-    [ -f $1 ] && rm $1
-  }
-
-  srv_remove="$AUTO_CPUFREQ_FILE-remove"
 
   # run uninstall in case of installed daemon
-  if [ -f $srv_remove -o -f $AUTO_CPUFREQ_FILE ]; then
+  if [ -f $srv_remove ]; then
-    eval "$AUTO_CPUFREQ_FILE --remove"
+    eval $tool_proc_rm
-  else
-    echo; echo "Couldn't remove the auto-cpufreq daemon, $srv_remove do not exist."
   fi
 
   # remove auto-cpufreq and all its supporting files
-  remove_directory $SHARE_DIR
+  [ -f $files ] && cat $files | xargs sudo rm -rf && rm -f $files
+  [ -d $share_dir ] && rm -rf $share_dir
 
-  remove_file "$AUTO_CPUFREQ_FILE-install"
+  # files cleanup
-  remove_file $srv_remove
+  [ -f $srv_install ] && rm $srv_install
-  remove_file $AUTO_CPUFREQ_FILE
+  [ -f $srv_remove ] && rm $srv_remove
-  remove_file $AUTO_CPUFREQ_GTK_FILE
+  [ -f $stats_file ] && rm $stats_file
-  remove_file $IMG_FILE
+  [ -f $unit_file ] && rm $unit_file
-  remove_file $ORG_FILE
+  [ -f $wrapper_script ] && rm $wrapper_script
-  remove_file "/usr/local/bin/cpufreqctl.auto-cpufreq"
+  [ -f $cpufreqctl ] && rm $cpufreqctl
-  remove_file "/var/run/auto-cpufreq.stats"
-
-  remove_file "$APPLICATIONS_PATH/$AUTO_CPUFREQ_GTK_DESKTOP_FILE"
-  update-desktop-database $APPLICATIONS_PATH
 
   # remove python virtual environment
-  remove_directory $venv_path
+  rm -rf "${venv_path}"
 
-  echo; echo "auto-cpufreq tool and all its supporting files successfully removed"; echo
+  separator
+  echo -e "\nauto-cpufreq tool and all its supporting files successfully removed."
+  separator
 }
 
-# root check
+function ask_operation {
-if ((EUID != 0)); then
+  echo -e "\n-------------------------- auto-cpufreq installer -----------------------------"
-  echo; echo "Must be run as root (i.e: 'sudo $0')."; echo
+  echo -e "\nWelcome to auto-cpufreq tool installer."
-  exit 1
+  echo -e "\nOptions:\n"
-fi
+  read -p \
+"[I]nstall
+[R]emove
+[Q]uit
 
-if [[ -z "$1" ]]; then ask_operation
+Select a key: [i/r/q]: " answer
+}
+# End of functions
+
+root_check
+
+if [[ -z "${1}" ]]; then
+  ask_operation
 else
-  case "$1" in
+  case "${1}" in
-    --install) answer="i";;
+  "--install")
-    --remove) answer="r";;
+    answer="i"
-    *) ask_operation;;
+    ;;
+  "--remove")
+    answer="r"
+    ;;
+  *)
+    answer="n"
+    ;;
   esac
 fi
 
 case $answer in
-	I|i) tool_install;;
+	I|i)
-	R|r) tool_remove;;
+	tool_install ;;
+	R|r)
+	tool_remove ;;
+	Q|q)
+	separator
+	echo ""
+	exit 0 ;;
 	*)
-    echo "Unknown key, aborting ..."; echo
+	separator
-    exit 1
+	echo -e "\nUnknown key, aborting ...\n"
-  ;;
+	exit 1 ;;
 esac

auto-cpufreq.conf-example

@@ -4,25 +4,6 @@
 # preferred governor.
 governor = performance
 
-# EPP: see available preferences by running: cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_available_preferences
-energy_performance_preference = performance
-
-# EPB (Energy Performance Bias) for the intel_pstate driver
-# see conversion info: https://www.kernel.org/doc/html/latest/admin-guide/pm/intel_epb.html
-# available EPB options include a numeric value between 0-15
-# (where 0 = maximum performance and 15 = maximum power saving),
-# or one of the following strings:
-# performance (0), balance_performance (4), default (6), balance_power (8), or power (15)
-# if the parameter is missing in the config and the hardware supports this setting, the default value will be used
-# the default value is `balance_performance` (for charger)
-# energy_perf_bias = balance_performance
-
-# Platform Profiles
-# https://www.kernel.org/doc/html/latest/userspace-api/sysfs-platform_profile.html
-# See available options by running:
-# cat /sys/firmware/acpi/platform_profile_choices
-# platform_profile = performance
-
 # minimum cpu frequency (in kHz)
 # example: for 800 MHz = 800000 kHz --> scaling_min_freq = 800000
 # see conversion info: https://www.rapidtables.com/convert/frequency/mhz-to-hz.html
@@ -38,42 +19,12 @@ energy_performance_preference = performance
 # turbo boost setting. possible values: always, auto, never
 turbo = auto
 
-
-# this is for ignoring controllers and other connected devices battery from affecting 
-# laptop preformence
-# [power_supply_ignore_list]
-
-# name1 = this
-# name2 = is
-# name3 = an
-# name4 = example
-
-
 # settings for when using battery power
 [battery]
 # see available governors by running: cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors
 # preferred governor
 governor = powersave
 
-# EPP: see available preferences by running: cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_available_preferences
-energy_performance_preference = power
-
-# EPB (Energy Performance Bias) for the intel_pstate driver
-# see conversion info: https://www.kernel.org/doc/html/latest/admin-guide/pm/intel_epb.html
-# available EPB options include a numeric value between 0-15
-# (where 0 = maximum performance and 15 = maximum power saving),
-# or one of the following strings:
-# performance (0), balance_performance (4), default (6), balance_power (8), or power (15)
-# if the parameter is missing in the config and the hardware supports this setting, the default value will be used
-# the default value is `balance_power` (for battery)
-# energy_perf_bias = balance_power
-
-# Platform Profiles
-# https://www.kernel.org/doc/html/latest/userspace-api/sysfs-platform_profile.html
-# See available options by running:
-# cat /sys/firmware/acpi/platform_profile_choices
-# platform_profile = low-power
-
 # minimum cpu frequency (in kHz)
 # example: for 800 MHz = 800000 kHz --> scaling_min_freq = 800000
 # see conversion info: https://www.rapidtables.com/convert/frequency/mhz-to-hz.html
@@ -88,17 +39,3 @@ energy_performance_preference = power
 
 # turbo boost setting. possible values: always, auto, never
 turbo = auto
-
-# experimental 
-
-# Add battery charging threshold (currently only available to Lenovo)
-# checkout README.md for more info
-
-# enable thresholds true or false
-#enable_thresholds = true
-#
-# start threshold (0 is off ) can be 0-99
-#start_threshold = 0
-#
-# stop threshold (100 is off) can be 1-100
-#stop_threshold = 100

auto_cpufreq/battery_scripts/battery.py

@@ -1,20 +0,0 @@
-#!/usr/bin/env python3
-from subprocess import PIPE, run
-
-from auto_cpufreq.battery_scripts.ideapad_acpi import ideapad_acpi_print_thresholds, ideapad_acpi_setup
-from auto_cpufreq.battery_scripts.ideapad_laptop import ideapad_laptop_print_thresholds, ideapad_laptop_setup
-from auto_cpufreq.battery_scripts.thinkpad import thinkpad_print_thresholds, thinkpad_setup
-
-def lsmod(module): return module in run(['lsmod'], stdout=PIPE, stderr=PIPE, text=True, shell=True).stdout
-
-def battery_get_thresholds():
-    if lsmod("ideapad_acpi"): ideapad_acpi_print_thresholds()
-    elif lsmod("ideapad_laptop"): ideapad_laptop_print_thresholds()
-    elif lsmod("thinkpad_acpi"): thinkpad_print_thresholds()
-    else: return
-
-def battery_setup():
-    if lsmod("ideapad_acpi"): ideapad_acpi_setup()
-    elif lsmod("ideapad_laptop"): ideapad_laptop_setup()
-    elif lsmod("thinkpad_acpi"): thinkpad_setup()
-    else: return

auto_cpufreq/battery_scripts/ideapad_acpi.py

@@ -1,38 +0,0 @@
-#!/usr/bin/env python3
-import os
-from subprocess import check_output
-
-from auto_cpufreq.config.config import config
-from auto_cpufreq.globals import POWER_SUPPLY_DIR
-
-def set_battery(value, mode, bat):
-    path = f"{POWER_SUPPLY_DIR}{bat}/charge_{mode}_threshold"
-    if os.path.isfile(path): check_output(f"echo {value} | tee {path}", shell=True, text=True)
-    else: print(f"WARNING: {path} does NOT exist")
-
-def get_threshold_value(mode):
-    conf = config.get_config()
-    return conf["battery"][f"{mode}_threshold"] if conf.has_option("battery", f"{mode}_threshold") else (0 if mode == "start" else 100)
-
-def ideapad_acpi_setup():
-    conf = config.get_config()
-
-    if not (conf.has_option("battery", "enable_thresholds") and conf["battery"]["enable_thresholds"] == "true"): return
-
-    if os.path.exists(POWER_SUPPLY_DIR):
-        batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith('BAT')]
-        
-        for bat in batteries:
-            set_battery(get_threshold_value("start"), "start", bat)
-            set_battery(get_threshold_value("stop"), "stop", bat)
-    else: print("WARNING: could NOT access", POWER_SUPPLY_DIR)
-
-def ideapad_acpi_print_thresholds():
-    batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith('BAT')]
-    print("\n-------------------------------- Battery Info ---------------------------------\n")
-    print(f"battery count = {len(batteries)}")
-    for bat in batteries:
-        try:
-            print(bat, "start threshold =", check_output(["cat", POWER_SUPPLY_DIR+bat+"/charge_start_threshold"]))
-            print(bat, "stop threshold =", check_output(["cat", POWER_SUPPLY_DIR+bat+"/charge_stop_threshold"]))
-        except Exception as e: print(f"ERROR: failed to read battery {bat} thresholds:", repr(e))

auto_cpufreq/battery_scripts/ideapad_laptop.py

@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-import os
-from subprocess import check_output
-
-from auto_cpufreq.config.config import config
-from auto_cpufreq.globals import CONSERVATION_MODE_FILE, POWER_SUPPLY_DIR
-
-def set_battery(value, mode, bat):
-    path = f"{POWER_SUPPLY_DIR}{bat}/charge_{mode}_threshold"
-    if os.path.exists(path):
-        check_output(f"echo {value} | tee {POWER_SUPPLY_DIR}{bat}/charge_{mode}_threshold", shell=True, text=True)
-    else: print(f"WARNING: {path} does NOT exist")
-
-def get_threshold_value(mode):
-    conf = config.get_config()
-    return conf["battery"][f"{mode}_threshold"] if conf.has_option("battery", f"{mode}_threshold") else (0 if mode == "start" else 100)
-
-def conservation_mode(value):
-    try:
-        check_output(f"echo {value} | tee {CONSERVATION_MODE_FILE}", shell=True, text=True)
-        print(f"conservation_mode is {value}")
-    except: print("unable to set conservation mode")
-    return
-
-def check_conservation_mode():
-    try:
-        value = check_output(["cat", CONSERVATION_MODE_FILE], text=True).rstrip()
-        if value == "1": return True
-        elif value == "0": return False
-        else:
-            print("could not get value from conservation mode")
-            return None
-    except:
-        print("could not get the value from conservation mode")
-        return False
-
-def ideapad_laptop_setup():
-    conf = config.get_config()
-
-    if not (conf.has_option("battery", "enable_thresholds") and conf["battery"]["enable_thresholds"] == "true"): return
-
-    batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith("BAT")]
-
-    if conf.has_option("battery", "ideapad_laptop_conservation_mode"):
-        if conf["battery"]["ideapad_laptop_conservation_mode"] == "true":
-            conservation_mode(1)
-            return
-        if conf["battery"]["ideapad_laptop_conservation_mode"] == "false": conservation_mode(0)
-
-    if not check_conservation_mode():
-        for bat in batteries:
-            set_battery(get_threshold_value("start"), "start", bat)
-            set_battery(get_threshold_value("stop"), "stop", bat)
-    else: print("conservation mode is enabled unable to set thresholds")
-
-def ideapad_laptop_print_thresholds():
-    if check_conservation_mode():
-        print("conservation mode is on")
-        return
-
-    batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith("BAT")]
-
-    print("\n-------------------------------- Battery Info ---------------------------------\n")
-    print(f"battery count = {len(batteries)}")
-    for bat in batteries:
-        try:
-            print(bat, "start threshold =", check_output(["cat", POWER_SUPPLY_DIR+bat+"/charge_start_threshold"]))
-            print(bat, "stop threshold =", check_output(["cat", POWER_SUPPLY_DIR+bat+"/charge_stop_threshold"]))
-        except Exception as e: print(f"ERROR: failed to read battery {bat} thresholds:", repr(e))

auto_cpufreq/battery_scripts/thinkpad.py

@@ -1,39 +0,0 @@
-#!/usr/bin/env python3
-import os
-from subprocess import check_output
-
-from auto_cpufreq.config.config import config
-from auto_cpufreq.globals import POWER_SUPPLY_DIR
-
-def set_battery(value, mode, bat):
-    path = f"{POWER_SUPPLY_DIR}{bat}/charge_{mode}_threshold"
-    if os.path.isfile(path): check_output(f"echo {value} | tee {path}", shell=True, text=True)
-    else: print(f"WARNING: {path} does NOT exist")
-
-def get_threshold_value(mode):
-    conf = config.get_config()
-    return conf["battery"][f"{mode}_threshold"] if conf.has_option("battery", f"{mode}_threshold") else (0 if mode == "start" else 100)
-
-def thinkpad_setup():
-    conf = config.get_config()
-
-    if not (conf.has_option("battery", "enable_thresholds") and conf["battery"]["enable_thresholds"] == "true"): return
-
-    if os.path.exists(POWER_SUPPLY_DIR):
-        batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith('BAT')]
-
-        for bat in batteries:
-            set_battery(get_threshold_value("start"), "start", bat)
-            set_battery(get_threshold_value("stop"), "stop", bat)
-    else: print(f"WARNING {POWER_SUPPLY_DIR} does NOT esixt")
-
-
-def thinkpad_print_thresholds():
-    batteries = [name for name in os.listdir(POWER_SUPPLY_DIR) if name.startswith('BAT')]
-    print("\n-------------------------------- Battery Info ---------------------------------\n")
-    print(f"battery count = {len(batteries)}")
-    for bat in batteries:
-        try:
-            print(bat, "start threshold =", check_output(["cat", POWER_SUPPLY_DIR+bat+"/charge_start_threshold"]))
-            print(bat, "stop threshold =", check_output(["cat", POWER_SUPPLY_DIR+bat+"/charge_stop_threshold"]))
-        except Exception as e: print(f"ERROR: failed to read battery {bat} thresholds:", repr(e))

auto_cpufreq/bin/auto_cpufreq.py

@@ -1,295 +0,0 @@
-#!/usr/bin/env python3
-#
-# auto-cpufreq - Automatic CPU speed & power optimizer for Linux
-#
-# Blog post: https://foolcontrol.org/?p=3124
-
-# core import
-import sys, time, os
-from subprocess import run
-from shutil import rmtree
-
-from auto_cpufreq.battery_scripts.battery import *
-from auto_cpufreq.config.config import config as conf, find_config_file
-from auto_cpufreq.core import *
-from auto_cpufreq.globals import GITHUB, IS_INSTALLED_WITH_AUR, IS_INSTALLED_WITH_SNAP
-from auto_cpufreq.modules.system_monitor import ViewType, SystemMonitor
-# import everything from power_helper, including bluetooth_disable and bluetooth_enable
-from auto_cpufreq.power_helper import *
-from threading import Thread
-
-@click.command()
-@click.option("--monitor", is_flag=True, help="Monitor and see suggestions for CPU optimizations")
-@click.option("--live", is_flag=True, help="Monitor and make (temp.) suggested CPU optimizations")
-@click.option("--daemon", is_flag=True, hidden=True)
-@click.option("--install", is_flag=True, help="Install daemon for (permanent) automatic CPU optimizations")
-@click.option("--update", is_flag=False, help="Update daemon and package for (permanent) automatic CPU optimizations", flag_value="--update")
-@click.option("--remove", is_flag=True, help="Remove daemon for (permanent) automatic CPU optimizations")
-@click.option("--force", is_flag=False, help="Force use of either \"powersave\" or \"performance\" governors. Setting to \"reset\" will go back to normal mode")
-@click.option("--config", is_flag=False, required=False, help="Use config file at defined path",)
-@click.option("--stats", is_flag=True, help="View live stats of CPU optimizations made by daemon")
-@click.option("--get-state", is_flag=True, hidden=True)
-@click.option("--bluetooth_boot_off", is_flag=True, help="Turn off Bluetooth on boot")
-@click.option("--bluetooth_boot_on", is_flag=True, help="Turn on Bluetooth on boot")
-@click.option("--debug", is_flag=True, help="Show debug info (include when submitting bugs)")
-@click.option("--version", is_flag=True, help="Show currently installed version")
-@click.option("--donate", is_flag=True, help="Support the project")
-def main(monitor, live, daemon, install, update, remove, force, config, stats, get_state,
-          bluetooth_boot_off, bluetooth_boot_on, debug, version, donate):
-    # display info if config file is used
-    config_path = find_config_file(config)
-    conf.set_path(config_path)
-    def config_info_dialog():
-        if conf.has_config():
-            print("\nUsing settings defined in " + config_path + " file")
-
-    if len(sys.argv) == 1:
-        print("\n" + "-" * 32 + " auto-cpufreq " + "-" * 33 + "\n")
-        print("Automatic CPU speed & power optimizer for Linux")
- 
-        print("\nExample usage:\nauto-cpufreq --monitor")
-        print("\n-----\n")
-
-        run(["auto-cpufreq", "--help"])
-        footer()
-    else:
-        # set governor override unless None or invalid
-        if force is not None:
-            not_running_daemon_check()
-            root_check() # Calling root_check before set_override as it will require sudo access
-            set_override(force) # Calling set override, only if force has some values
-
-        if monitor:
-            root_check()
-            battery_setup()
-            conf.notifier.start()
-            if IS_INSTALLED_WITH_SNAP:
-                gnome_power_detect_snap()
-                tlp_service_detect_snap()
-            else:
-                gnome_power_detect()
-                tlp_service_detect()
-                
-            if IS_INSTALLED_WITH_SNAP or tlp_stat_exists or (systemctl_exists and not bool(gnome_power_status)):
-                try:
-                    input("press Enter to continue or Ctrl + c to exit...")
-                except KeyboardInterrupt:
-                    conf.notifier.stop()
-                    sys.exit(0)
-            
-            monitor = SystemMonitor(suggestion=True, type=ViewType.MONITOR)
-            monitor.run(on_quit=conf.notifier.stop)
-        elif live:
-            root_check()
-            battery_setup()
-            conf.notifier.start()
-            if IS_INSTALLED_WITH_SNAP:
-                gnome_power_detect_snap()
-                tlp_service_detect_snap()
-            else:
-                gnome_power_detect_install()
-                gnome_power_stop_live()
-                tuned_stop_live()
-                tlp_service_detect()
-            
-            if IS_INSTALLED_WITH_SNAP or tlp_stat_exists or (systemctl_exists and not bool(gnome_power_status)):
-                try:
-                    input("press Enter to continue or Ctrl + c to exit...")
-                except KeyboardInterrupt:
-                    conf.notifier.stop()
-                    sys.exit(0)
-            
-            cpufreqctl()
-            def live_daemon():
-                # Redirect stdout to suppress prints
-                class NullWriter:
-                    def write(self, _): pass
-                    def flush(self): pass
-                try:
-                    sys.stdout = NullWriter()
-                    
-                    while True:
-                        time.sleep(1)
-                        set_autofreq()
-                except:
-                    pass
-            
-            def live_daemon_off():
-                gnome_power_start_live()
-                tuned_start_live()
-                cpufreqctl_restore()
-                conf.notifier.stop()
-            
-            thread = Thread(target=live_daemon, daemon=True)
-            thread.start()
-            
-            monitor = SystemMonitor(type=ViewType.LIVE)
-            monitor.run(on_quit=live_daemon_off)
-        elif daemon:
-            config_info_dialog()
-            root_check()
-            file_stats()
-            if IS_INSTALLED_WITH_SNAP and SNAP_DAEMON_CHECK == "enabled":
-                gnome_power_detect_snap()
-                tlp_service_detect_snap()
-            elif not IS_INSTALLED_WITH_SNAP:
-                gnome_power_detect()
-                tlp_service_detect()
-            battery_setup()
-            conf.notifier.start()
-            while True:
-                try:
-                    footer()
-                    gov_check()
-                    cpufreqctl()
-                    distro_info()
-                    sysinfo()
-                    set_autofreq()
-                    countdown(2)
-                except KeyboardInterrupt: break
-            conf.notifier.stop()
-        elif install:
-            root_check()
-            if IS_INSTALLED_WITH_SNAP:
-                running_daemon_check()
-                gnome_power_detect_snap()
-                tlp_service_detect_snap()
-                bluetooth_notif_snap()
-                gov_check()
-                run("snapctl set daemon=enabled", shell=True)
-                run("snapctl start --enable auto-cpufreq", shell=True)
-            else:
-                running_daemon_check()
-                gov_check()
-                deploy_daemon()
-            deploy_complete_msg()
-        elif update:
-            root_check()
-            custom_dir = "/opt/auto-cpufreq/source"
-            for arg in sys.argv:
-                if arg.startswith("--update="):
-                    custom_dir = arg.split("=")[1]
-                    sys.argv.remove(arg)
-                    
-            if "--update" in sys.argv:
-                update = True
-                sys.argv.remove("--update")
-                if len(sys.argv) == 2: custom_dir = sys.argv[1] 
-                    
-            if IS_INSTALLED_WITH_SNAP:
-                print("Detected auto-cpufreq was installed using snap")
-                # refresh snap directly using this command
-                # path wont work in this case
-
-                print("Please update using snap package manager, i.e: `sudo snap refresh auto-cpufreq`.")
-                #check for AUR 
-            elif IS_INSTALLED_WITH_AUR: print("Arch-based distribution with AUR support detected. Please refresh auto-cpufreq using your AUR helper.")
-            else:
-                is_new_update = check_for_update()
-                if not is_new_update: return
-                ans = input("Do you want to update auto-cpufreq to the latest release? [Y/n]: ").strip().lower()
-                if not os.path.exists(custom_dir): os.makedirs(custom_dir)
-                if os.path.exists(os.path.join(custom_dir, "auto-cpufreq")): rmtree(os.path.join(custom_dir, "auto-cpufreq"))
-                if ans in ['', 'y', 'yes']:
-                    remove_daemon()
-                    remove_complete_msg()
-                    new_update(custom_dir)
-                    print("enabling daemon")
-                    run(["auto-cpufreq", "--install"])
-                    print("auto-cpufreq is installed with the latest version")
-                    run(["auto-cpufreq", "--version"])
-                else: print("Aborted")
-        elif remove:
-            root_check()
-            if IS_INSTALLED_WITH_SNAP:
-                run("snapctl set daemon=disabled", shell=True)
-                run("snapctl stop --disable auto-cpufreq", shell=True)
-                if auto_cpufreq_stats_path.exists():
-                    if auto_cpufreq_stats_file is not None:
-                        auto_cpufreq_stats_file.close()
-
-                    auto_cpufreq_stats_path.unlink()
-                # ToDo: 
-                # {the following snippet also used in --update, update it there too(if required)}
-                # * undo bluetooth boot disable
-                gnome_power_rm_reminder_snap()
-            else: remove_daemon()
-            remove_complete_msg()
-        elif stats:
-            not_running_daemon_check()
-            config_info_dialog()
-            if IS_INSTALLED_WITH_SNAP:
-                gnome_power_detect_snap()
-                tlp_service_detect_snap()
-            else:
-                gnome_power_detect()
-                tlp_service_detect()
-            
-            if IS_INSTALLED_WITH_SNAP or tlp_stat_exists or (systemctl_exists and not bool(gnome_power_status)):
-                try:
-                    input("press Enter to continue or Ctrl + c to exit...")
-                except KeyboardInterrupt:
-                    conf.notifier.stop()
-                    sys.exit(0)
-            
-            monitor = SystemMonitor(type=ViewType.STATS)
-            monitor.run()
-        elif get_state:
-            not_running_daemon_check()
-            override = get_override()
-            print(override)
-        elif bluetooth_boot_off:
-            if IS_INSTALLED_WITH_SNAP:
-                footer()
-                bluetooth_notif_snap()
-                footer()
-            else:
-                footer()
-                root_check()
-                bluetooth_disable()
-                footer()
-        elif bluetooth_boot_on:
-            if IS_INSTALLED_WITH_SNAP:
-                footer()
-                bluetooth_on_notif_snap()
-                footer()
-            else:
-                footer()
-                root_check()
-                bluetooth_enable()
-                footer()
-        elif debug:
-            # ToDo: add status of GNOME Power Profile service status
-            config_info_dialog()
-            root_check()
-            battery_get_thresholds()
-            cpufreqctl()
-            footer()
-            distro_info()
-            sysinfo()
-            print()
-            app_version()
-            print()
-            python_info()
-            print()
-            device_info()
-            print(f"Battery is: {'' if charging() else 'dis'}charging")
-            print()
-            app_res_use()
-            get_load()
-            get_current_gov()
-            get_turbo()
-            footer()
-        elif version:
-            footer()
-            distro_info()
-            app_version()
-            footer()
-        elif donate:
-            footer()
-            print("If auto-cpufreq helped you out and you find it useful ...\n")
-            print("Show your appreciation by donating!")
-            print(GITHUB+"#donate")
-            footer()
-                
-if __name__ == "__main__": main()

auto_cpufreq/bin/auto_cpufreq_gtk.py

@@ -1,16 +0,0 @@
-#!/usr/bin/env python3
-import gi
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, GLib
-
-from auto_cpufreq.gui.app import ToolWindow
-
-def main():
-    GLib.set_prgname("auto-cpufreq-gtk")
-    win = ToolWindow()
-    win.connect("destroy", Gtk.main_quit)
-    win.show_all()
-    win.handle_update()
-    Gtk.main()
-
-if __name__ == "__main__": main()

auto_cpufreq/config/config.py

@@ -1,68 +0,0 @@
-import os, pyinotify, sys
-from configparser import ConfigParser, ParsingError
-from subprocess import run, PIPE
-
-from auto_cpufreq.config.config_event_handler import ConfigEventHandler
-
-def find_config_file(args_config_file) -> str:
-    """
-    Find the config file to use.
-
-    Look for a config file in the following priorization order:
-    1. Command line argument
-    2. User config file
-    3. System config file
-
-    :param args_config_file: Path to the config file provided as a command line argument
-    :return: The path to the config file to use
-    """
-    # Prepare paths
-
-    # use $SUDO_USER or $USER to get home dir since sudo can't access
-    # user env vars
-    home = run(["getent passwd ${SUDO_USER:-$USER} | cut -d: -f6"],
-        shell=True,
-        stdout=PIPE,
-        universal_newlines=True
-    ).stdout.rstrip()
-    user_config_dir = os.getenv("XDG_CONFIG_HOME", default=os.path.join(home, ".config"))
-    user_config_file = os.path.join(user_config_dir, "auto-cpufreq/auto-cpufreq.conf")
-    system_config_file = "/etc/auto-cpufreq.conf"
-
-    if args_config_file is not None:                                # (1) Command line argument was specified
-        # Check if the config file path points to a valid file
-        if os.path.isfile(args_config_file): return args_config_file
-        else:
-            # Not a valid file
-            print(f"Config file specified with '--config {args_config_file}' not found.")
-            sys.exit(1)
-    elif os.path.isfile(user_config_file): return user_config_file  # (2) User config file
-    else: return system_config_file                                 # (3) System config file (default if nothing else is found)
-
-class _Config:
-    def __init__(self) -> None:
-        self.path: str = ""
-        self._config: ConfigParser = ConfigParser()
-        self.watch_manager: pyinotify.WatchManager = pyinotify.WatchManager()
-        self.config_handler = ConfigEventHandler(self)
-
-        # check for file changes using threading
-        self.notifier: pyinotify.ThreadedNotifier = pyinotify.ThreadedNotifier(self.watch_manager, self.config_handler)
-        
-    def set_path(self, path: str) -> None:
-        self.path = path
-        mask = pyinotify.IN_CREATE | pyinotify.IN_DELETE | pyinotify.IN_MODIFY | pyinotify.IN_MOVED_FROM | pyinotify.IN_MOVED_TO
-        self.watch_manager.add_watch(os.path.dirname(path), mask=mask)
-        if os.path.isfile(path): self.update_config()
-
-    def has_config(self) -> bool: return os.path.isfile(self.path)
-    
-    def get_config(self) -> ConfigParser: return self._config
-    
-    def update_config(self) -> None:
-        # create new ConfigParser to prevent old data from remaining
-        self._config = ConfigParser()
-        try: self._config.read(self.path)
-        except ParsingError as e: print(f"The following error occured while parsing the config file: \n{repr(e)}")
-
-config = _Config()

auto_cpufreq/config/config_event_handler.py

@@ -1,23 +0,0 @@
-from pyinotify import Event, ProcessEvent
-
-class ConfigEventHandler(ProcessEvent):
-    def __init__(self, config) -> None:
-        self.config = config
-
-    def _process_update(self, event: Event):
-        if event.pathname.rstrip("~") == self.config.path: self.config.update_config()
-
-    # activates when auto-cpufreq config file is modified
-    def process_IN_MODIFY(self, event: Event) -> None: self._process_update(event)
-
-    # activates when auto-cpufreq config file is deleted
-    def process_IN_DELETE(self, event: Event) -> None: self._process_update(event)
-
-    # activates when auto-cpufreq config file is created
-    def process_IN_CREATE(self, event: Event) -> None: self._process_update(event)
-
-    # activates when auto-cpufreq config file is moved from watched directory
-    def process_IN_MOVED_FROM(self, event: Event) -> None: self._process_update(event)
-
-    # activates when auto-cpufreq config file is moved into the watched directory
-    def process_IN_MOVED_TO(self, event: Event) -> None: self._process_update(event)

auto_cpufreq/globals.py

@@ -1,15 +0,0 @@
-from os import getenv, path
-from subprocess import getoutput
-
-ALL_GOVERNORS = ('performance', 'ondemand', 'conservative', 'schedutil', 'userspace', 'powersave') # from the highest performance to the lowest
-AVAILABLE_GOVERNORS = getoutput('cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors').strip().split(' ')
-AVAILABLE_GOVERNORS_SORTED = tuple(filter(lambda gov: gov in AVAILABLE_GOVERNORS, ALL_GOVERNORS))
-
-CONSERVATION_MODE_FILE = "/sys/bus/platform/drivers/ideapad_acpi/VPC2004:00/conservation_mode"
-GITHUB = "https://github.com/AdnanHodzic/auto-cpufreq"
-IS_INSTALLED_WITH_AUR = path.isfile("/etc/arch-release") and bool(getoutput("pacman -Qs auto-cpufreq"))
-IS_INSTALLED_WITH_SNAP = getenv("PKG_MARKER") == "SNAP"
-POWER_SUPPLY_DIR = "/sys/class/power_supply/"
-SNAP_DAEMON_CHECK = getoutput("snapctl get daemon")
-
-CPU_TEMP_SENSOR_PRIORITY = ("coretemp", "acpitz", "k10temp", "zenpower")

auto_cpufreq/gui/app.py

@@ -1,119 +0,0 @@
-import gi
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gdk, GdkPixbuf, Gio, GLib, Gtk
-
-from contextlib import redirect_stdout
-from io import StringIO
-from subprocess import PIPE, run
-from threading import Thread
-
-from auto_cpufreq.core import check_for_update, is_running
-from auto_cpufreq.globals import GITHUB, IS_INSTALLED_WITH_SNAP
-from auto_cpufreq.gui.objects import CPUFreqStatsLabel, CurrentGovernorBox, DaemonNotRunningView, DropDownMenu, RadioButtonView, SystemStatsLabel, UpdateDialog
-
-if IS_INSTALLED_WITH_SNAP:
-    CSS_FILE = "/snap/auto-cpufreq/current/style.css"
-    ICON_FILE = "/snap/auto-cpufreq/current/icon.png"
-else:
-    CSS_FILE = "/usr/local/share/auto-cpufreq/scripts/style.css"
-    ICON_FILE = "/usr/local/share/auto-cpufreq/images/icon.png"
-
-HBOX_PADDING = 20
-PKEXEC_ERROR = "Error executing command as another user: Not authorized\n\nThis incident has been reported.\n"
-
-class ToolWindow(Gtk.Window):
-    def __init__(self):
-        super().__init__(title="auto-cpufreq")
-        self.set_default_size(600, 480)
-        self.set_border_width(10)
-        self.set_resizable(False)
-        self.load_css()
-        pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(filename=ICON_FILE, width=500, height=500, preserve_aspect_ratio=True)
-        self.set_icon(pixbuf)
-        self.build()
-
-    def main(self):
-        # Main HBOX
-        self.hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=HBOX_PADDING)
-       
-        self.systemstats = SystemStatsLabel()
-        self.hbox.pack_start(self.systemstats, False, False, 0)
-        self.add(self.hbox)
-
-        self.vbox_right = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=52)
-        
-        self.menu = DropDownMenu(self)
-        self.hbox.pack_end(self.menu, False, False, 0)
-        
-        self.currentgovernor = CurrentGovernorBox()
-        self.vbox_right.pack_start(self.currentgovernor, False, False, 0)
-        self.vbox_right.pack_start(RadioButtonView(), False, False, 0)
-
-        self.cpufreqstats = CPUFreqStatsLabel()
-        self.vbox_right.pack_start(self.cpufreqstats, False, False, 0)
-
-        self.hbox.pack_start(self.vbox_right, False, False, 0)
-
-        GLib.timeout_add_seconds(5, self.refresh_in_thread)
-
-    def snap(self):
-        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, halign=Gtk.Align.CENTER, valign=Gtk.Align.CENTER)
-        # reference: https://forum.snapcraft.io/t/pkexec-not-found-python-gtk-gnome-app/36579
-        label = Gtk.Label(label="GUI not available due to Snap package confinement limitations.\nPlease install auto-cpufreq using auto-cpufreq-installer\nVisit the GitHub repo for more info")
-        label.set_justify(Gtk.Justification.CENTER)
-        button = Gtk.LinkButton.new_with_label(
-            uri=GITHUB,
-            label="GitHub Repo"
-        )
-        
-        box.pack_start(label, False, False, 0)
-        box.pack_start(button, False, False, 0)
-        self.add(box)
-
-    def handle_update(self):
-        new_stdout = StringIO()
-        with redirect_stdout(new_stdout):
-            if not check_for_update(): return
-        captured_output = new_stdout.getvalue().splitlines()
-        dialog = UpdateDialog(self, captured_output[1], captured_output[2])
-        response = dialog.run()
-        dialog.destroy()
-        if response != Gtk.ResponseType.YES: return
-        updater = run(["pkexec", "auto-cpufreq", "--update"], input="y\n", encoding="utf-8", stderr=PIPE)
-        if updater.stderr == PKEXEC_ERROR:
-            error = Gtk.MessageDialog(self, 0, Gtk.MessageType.ERROR, Gtk.ButtonsType.OK, "Error updating")
-            error.format_secondary_text("Authorization Failed")
-            error.run()
-            error.destroy()
-            return
-        success = Gtk.MessageDialog(self, 0, Gtk.MessageType.INFO, Gtk.ButtonsType.OK, "Update successful")
-        success.format_secondary_text("The app will now close. Please reopen to apply changes")
-        success.run()
-        success.destroy()
-        exit(0)
-
-    def daemon_not_running(self):
-        self.box = DaemonNotRunningView(self)
-        self.add(self.box)
-
-    def build(self):
-        if IS_INSTALLED_WITH_SNAP: self.snap()
-        elif is_running("auto-cpufreq", "--daemon"): self.main()
-        else: self.daemon_not_running()
-
-    def load_css(self):
-        screen = Gdk.Screen.get_default()
-        self.gtk_provider = Gtk.CssProvider()
-        self.gtk_context = Gtk.StyleContext()
-        self.gtk_context.add_provider_for_screen(screen, self.gtk_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
-        self.gtk_provider.load_from_file(Gio.File.new_for_path(CSS_FILE))
-
-    def refresh_in_thread(self):
-        Thread(target=self._refresh).start()
-        return True
-
-    def _refresh(self):
-        self.systemstats.refresh()
-        self.currentgovernor.refresh()
-        self.cpufreqstats.refresh()
-

auto_cpufreq/gui/objects.py

@@ -1,288 +0,0 @@
-import gi
-gi.require_version("Gtk", "3.0")
-from gi.repository import GdkPixbuf, Gtk
-
-import sys
-from concurrent.futures import ThreadPoolExecutor
-from io import StringIO
-from os.path import isfile
-from platform import python_version
-from subprocess import getoutput, PIPE, run
-
-from auto_cpufreq.core import distro_info, get_formatted_version, get_override, sysinfo
-from auto_cpufreq.globals import GITHUB, IS_INSTALLED_WITH_AUR, IS_INSTALLED_WITH_SNAP
-
-PKEXEC_ERROR = "Error executing command as another user: Not authorized\n\nThis incident has been reported.\n"
-
-auto_cpufreq_stats_path = ("/var/snap/auto-cpufreq/current" if IS_INSTALLED_WITH_SNAP else "/var/run") + "/auto-cpufreq.stats"
-
-def get_stats():
-    if isfile(auto_cpufreq_stats_path):
-        with open(auto_cpufreq_stats_path, "r") as file: stats = [line for line in (file.readlines() [-50:])]
-        return "".join(stats)
-
-def get_version():
-    # snap package
-    if IS_INSTALLED_WITH_SNAP: return getoutput(r"echo \(Snap\) $SNAP_VERSION")
-    # aur package
-    elif IS_INSTALLED_WITH_AUR: return getoutput("pacman -Qi auto-cpufreq | grep Version")
-    else:
-        # source code (auto-cpufreq-installer)
-        try: return get_formatted_version()
-        except Exception as e:
-            print(repr(e))
-            pass
-
-class RadioButtonView(Gtk.Box):
-    def __init__(self):
-        super().__init__(orientation=Gtk.Orientation.HORIZONTAL)
-
-        self.set_hexpand(True)
-        self.hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
-
-        self.label = Gtk.Label("Governor Override", name="bold")
-
-        self.default = Gtk.RadioButton.new_with_label_from_widget(None, "Default")
-        self.default.connect("toggled", self.on_button_toggled,  "reset")
-        self.default.set_halign(Gtk.Align.END)
-        self.powersave = Gtk.RadioButton.new_with_label_from_widget(self.default, "Powersave")
-        self.powersave.connect("toggled", self.on_button_toggled,  "powersave")
-        self.powersave.set_halign(Gtk.Align.END)
-        self.performance = Gtk.RadioButton.new_with_label_from_widget(self.default, "Performance")
-        self.performance.connect("toggled", self.on_button_toggled, "performance")
-        self.performance.set_halign(Gtk.Align.END)
-
-        # this keeps track of whether or not the button was toggled by the app or the user to prompt for authorization
-        self.set_by_app = True
-        self.set_selected()
-
-        self.pack_start(self.label, False, False, 0)
-        self.pack_start(self.default, True, True, 0)
-        self.pack_start(self.powersave, True, True, 0)
-        self.pack_start(self.performance, True, True, 0)
-
-    def on_button_toggled(self, button, override):
-        if button.get_active():
-            if not self.set_by_app:
-                result = run(f"pkexec auto-cpufreq --force={override}", shell=True, stdout=PIPE, stderr=PIPE)
-                if result.stderr.decode() == PKEXEC_ERROR: self.set_selected()
-            else: self.set_by_app = False
-
-    def set_selected(self):
-        override = get_override()
-        match override:
-            case "powersave": self.powersave.set_active(True)
-            case "performance": self.performance.set_active(True)
-            case "default":
-                # because this is the default button, it does not trigger the callback when set by the app
-                if self.set_by_app: self.set_by_app = False
-                self.default.set_active(True)
-
-class CurrentGovernorBox(Gtk.Box):
-    def __init__(self):
-        super().__init__(spacing=25)
-        self.static = Gtk.Label(label="Current Governor", name="bold")
-        self.governor = Gtk.Label(label=getoutput("cpufreqctl.auto-cpufreq --governor").strip().split(" ")[0], halign=Gtk.Align.END)
-
-        self.pack_start(self.static, False, False, 0)
-        self.pack_start(self.governor, False, False, 0)
-
-    def refresh(self):
-        self.governor.set_label(getoutput("cpufreqctl.auto-cpufreq --governor").strip().split(" ")[0])
-
-class SystemStatsLabel(Gtk.Label):
-    def __init__(self):
-        super().__init__()
-        self.refresh()
-
-    def refresh(self):
-        # change stdout and store label text to file-like object
-        old_stdout = sys.stdout
-        text = StringIO()
-        sys.stdout = text
-        distro_info()
-        sysinfo()
-        self.set_label(text.getvalue())
-        sys.stdout = old_stdout
-    
-class CPUFreqStatsLabel(Gtk.Label):
-    def __init__(self):
-        super().__init__()
-        self.refresh()
-  
-    def refresh(self):
-        stats = get_stats().split("\n")
-        start = None
-        for i, line in enumerate(stats):
-            if line == ("-" * 28 + " CPU frequency scaling " + "-" * 28):
-                start = i
-                break
-        if start is not None:
-            del stats[:i]
-            del stats[-4:]
-            self.set_label("\n".join(stats))
- 
-class DropDownMenu(Gtk.MenuButton):
-    def __init__(self, parent):
-        super().__init__()
-        self.set_halign(Gtk.Align.END)
-        self.set_valign(Gtk.Align.START)
-        self.image = Gtk.Image.new_from_icon_name("open-menu-symbolic", Gtk.IconSize.LARGE_TOOLBAR)
-        self.add(self.image)
-        self.menu = self.build_menu(parent)
-        self.set_popup(self.menu)
-
-    def build_menu(self, parent):
-        menu = Gtk.Menu()
-
-        daemon = Gtk.MenuItem(label="Remove Daemon")
-        daemon.connect("activate", self._remove_daemon, parent)
-        menu.append(daemon)
-
-        about = Gtk.MenuItem(label="About")
-        about.connect("activate", self.about_dialog, parent)
-        menu.append(about)
-
-        menu.show_all()
-        return menu
-
-    def about_dialog(self, MenuItem, parent):
-        dialog = AboutDialog(parent)
-        response = dialog.run()
-        dialog.destroy()
-
-    def _remove_daemon(self, MenuItem, parent):
-        confirm = ConfirmDialog(parent, message="Are you sure you want to remove the daemon?")
-        response = confirm.run()
-        confirm.destroy()
-        if response == Gtk.ResponseType.YES:
-            try:
-                # run in thread to prevent GUI from hanging
-                with ThreadPoolExecutor() as executor:
-                    kwargs = {"shell": True, "stdout": PIPE, "stderr": PIPE}
-                    future = executor.submit(run, "pkexec auto-cpufreq --remove", **kwargs)
-                    result = future.result()
-                assert result.stderr.decode() != PKEXEC_ERROR, Exception("Authorization was cancelled")
-                dialog = Gtk.MessageDialog(
-                    transient_for=parent,
-                    message_type=Gtk.MessageType.INFO,
-                    buttons=Gtk.ButtonsType.OK,
-                    text="Daemon successfully removed"
-                )
-                dialog.format_secondary_text("The app will now close. Please reopen to apply changes")
-                dialog.run()
-                dialog.destroy()
-                parent.destroy()
-            except Exception as e:
-                dialog = Gtk.MessageDialog(
-                    transient_for=parent,
-                    message_type=Gtk.MessageType.ERROR,
-                    buttons=Gtk.ButtonsType.OK,
-                    text="Daemon removal failed"
-                )
-                dialog.format_secondary_text(f"The following error occured:\n{e}")
-                dialog.run()
-                dialog.destroy()
-
-class AboutDialog(Gtk.Dialog):
-    def __init__(self, parent):
-        super().__init__(title="About", transient_for=parent)
-        app_version = get_version()
-        self.box = self.get_content_area()
-        self.box.set_spacing(10)
-        self.add_button("Close", Gtk.ResponseType.CLOSE)
-        self.set_default_size(400, 350)
-        img_buffer = GdkPixbuf.Pixbuf.new_from_file_at_scale(
-            filename="/usr/local/share/auto-cpufreq/images/icon.png",
-            width=150,
-            height=150,
-            preserve_aspect_ratio=True
-        )
-        self.image = Gtk.Image.new_from_pixbuf(img_buffer)
-        self.title = Gtk.Label(label="auto-cpufreq", name="bold")
-        self.version = Gtk.Label(label=app_version)
-        self.python = Gtk.Label(label=f"Python {python_version()}")
-        self.github = Gtk.Label(label=GITHUB)
-        self.license = Gtk.Label(label="Licensed under LGPL3", name="small")
-        self.love = Gtk.Label(label="Made with <3", name="small")
-
-        self.box.pack_start(self.image, False, False, 0)
-        self.box.pack_start(self.title, False, False, 0)
-        self.box.pack_start(self.version, False, False, 0)
-        self.box.pack_start(self.python, False, False, 0)
-        self.box.pack_start(self.github, False, False, 0)
-        self.box.pack_start(self.license, False, False, 0)
-        self.box.pack_start(self.love, False, False, 0)
-        self.show_all()
-
-class UpdateDialog(Gtk.Dialog):
-    def __init__(self, parent, current_version: str, latest_version: str):
-        super().__init__(title="Update Available", transient_for=parent)
-        self.box = self.get_content_area()
-        self.set_default_size(400, 100)
-        self.add_buttons("Update", Gtk.ResponseType.YES, "Cancel", Gtk.ResponseType.NO)
-        self.label = Gtk.Label(label="An update is available\n")
-        self.current_version = Gtk.Label(label=current_version + "\n")
-        self.latest_version = Gtk.Label(label=latest_version + "\n")
-
-        self.box.pack_start(self.label, True, False, 0)
-        self.box.pack_start(self.current_version, True, False, 0)
-        self.box.pack_start(self.latest_version, True, False, 0)
-
-        self.show_all()
-
-class ConfirmDialog(Gtk.Dialog):
-    def __init__(self, parent, message: str):
-        super().__init__(title="Confirmation", transient_for=parent)
-        self.box = self.get_content_area()
-        self.set_default_size(400, 100)
-        self.add_buttons("Yes", Gtk.ResponseType.YES, "No", Gtk.ResponseType.NO)
-        self.label = Gtk.Label(label=message)
-
-        self.box.pack_start(self.label, True, False, 0)
-
-        self.show_all()
-
-class DaemonNotRunningView(Gtk.Box):
-    def __init__(self, parent):
-        super().__init__(orientation=Gtk.Orientation.VERTICAL, spacing=10, halign=Gtk.Align.CENTER, valign=Gtk.Align.CENTER)
-
-        self.label = Gtk.Label(label="auto-cpufreq daemon is not running. Please click the install button")
-        self.install_button = Gtk.Button.new_with_label("Install")
-
-        self.install_button.connect("clicked", self.install_daemon, parent)
-
-        self.pack_start(self.label, False, False, 0)
-        self.pack_start(self.install_button, False, False, 0)
-
-    def install_daemon(self, button, parent):
-        try:
-            # run in thread to prevent GUI from hanging
-            with ThreadPoolExecutor() as executor:
-                kwargs = {"shell": True, "stdout": PIPE, "stderr": PIPE}
-                future = executor.submit(run, "pkexec auto-cpufreq --install", **kwargs)
-                result = future.result()
-            assert result.stderr.decode() != PKEXEC_ERROR, Exception("Authorization was cancelled")
-            # enable for debug. causes issues if kept
-            # elif result.stderr is not None:
-            #     raise Exception(result.stderr.decode())
-            dialog = Gtk.MessageDialog(
-                transient_for=parent,
-                message_type=Gtk.MessageType.INFO,
-                buttons=Gtk.ButtonsType.OK,
-                text="Daemon successfully installed"
-            )
-            dialog.format_secondary_text("The app will now close. Please reopen to apply changes")
-            dialog.run()
-            dialog.destroy()
-            parent.destroy()
-        except Exception as e:
-            dialog = Gtk.MessageDialog(
-                transient_for=parent,
-                message_type=Gtk.MessageType.ERROR,
-                buttons=Gtk.ButtonsType.OK,
-                text="Daemon install failed"
-            )
-            dialog.format_secondary_text(f"The following error occured:\n{e}")
-            dialog.run()
-            dialog.destroy()

auto_cpufreq/gui/tray.py

@@ -1,28 +0,0 @@
-import gi
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, AppIndicator3 as appindicator
-
-from subprocess import run
-
-def main():
-    indicator = appindicator.Indicator.new("auto-cpufreq-tray", "network-idle-symbolic", appindicator.IndicatorCategory.APPLICATION_STATUS)
-    indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
-    indicator.set_menu(build_menu())
-    Gtk.main()
-
-def build_menu():
-    menu = Gtk.Menu()
-
-    program = Gtk.MenuItem("auto-cpufreq")
-    program.connect("activate", open_app)
-    menu.append(program)
-
-    _quit = Gtk.MenuItem("Quit")
-    _quit.connect("activate", Gtk.main_quit)
-    menu.append(_quit)
-    menu.show_all()
-    return menu
-
-def open_app(MenuItem): run("sudo -E python app.py", shell=True)
-
-if __name__ == "__main__": main()

auto_cpufreq/modules/system_info.py

@@ -1,337 +0,0 @@
-from dataclasses import dataclass
-import os
-from pathlib import Path
-import platform
-from subprocess import getoutput
-from typing import Tuple, List
-import psutil
-import distro
-from pathlib import Path
-from auto_cpufreq.config.config import config
-from auto_cpufreq.core import get_power_supply_ignore_list
-from auto_cpufreq.globals import (
-    AVAILABLE_GOVERNORS_SORTED,
-    CPU_TEMP_SENSOR_PRIORITY,
-    IS_INSTALLED_WITH_SNAP,
-    POWER_SUPPLY_DIR,
-)
-
-
-@dataclass
-class CoreInfo:
-    id: int
-    usage: float
-    temperature: float
-    frequency: float
-
-
-@dataclass
-class BatteryInfo:
-    is_charging: bool | None
-    is_ac_plugged: bool | None
-    charging_start_threshold: int | None
-    charging_stop_threshold: int | None
-    battery_level: int | None
-    power_consumption: float | None
-
-    def __repr__(self) -> str:
-        if self.is_charging:
-            return "charging"
-        elif not self.is_ac_plugged:
-            return f"discharging {('(' + '{:.2f}'.format(self.power_consumption) + ' W)') if self.power_consumption != None else ''}"
-        return "Not Charging"
-
-
-@dataclass
-class SystemReport:
-    distro_name: str
-    distro_ver: str
-    arch: str
-    processor_model: str
-    total_core: int | None
-    kernel_version: str
-    current_gov: str | None
-    current_epp: str | None
-    current_epb: str | None
-    cpu_driver: str
-    cpu_fan_speed: int | None
-    cpu_usage: float
-    cpu_max_freq: float | None
-    cpu_min_freq: float | None
-    load: float
-    avg_load: Tuple[float, float, float] | None
-    cores_info: list[CoreInfo]
-    battery_info: BatteryInfo
-    is_turbo_on: Tuple[bool | None, bool | None]
-
-
-class SystemInfo:
-    """
-    Provides system information related to CPU, distribution, and performance metrics.
-    """
-
-    def __init__(self):
-        self.distro_name: str = (
-            distro.name(pretty=True) if not IS_INSTALLED_WITH_SNAP else "UNKNOWN"
-        )
-        self.distro_version: str = (
-            distro.version() if not IS_INSTALLED_WITH_SNAP else "UNKNOWN"
-        )
-        self.architecture: str = platform.machine()
-        self.processor_model: str = (
-            getoutput("grep -E 'model name' /proc/cpuinfo -m 1").split(":")[-1].strip()
-        )
-        self.total_cores: int | None = psutil.cpu_count(logical=True)
-        self.cpu_driver: str = getoutput(
-            "cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_driver"
-        ).strip()
-        self.kernel_version: str = platform.release()
-
-    @staticmethod
-    def cpu_min_freq() -> float | None:
-        freqs = psutil.cpu_freq(percpu=True)
-        return min((freq.min for freq in freqs), default=None)
-
-    @staticmethod
-    def cpu_max_freq() -> float | None:
-        freqs = psutil.cpu_freq(percpu=True)
-        return max((freq.max for freq in freqs), default=None)
-
-    @staticmethod
-    def get_cpu_info() -> List[CoreInfo]:
-        """Returns detailed CPU information for each core."""
-        cpu_usage = psutil.cpu_percent(percpu=True)
-        cpu_freqs = psutil.cpu_freq(percpu=True)
-
-        try:
-            temps = psutil.sensors_temperatures()
-            temp_sensor = []
-            for sensor in CPU_TEMP_SENSOR_PRIORITY:
-                temp_sensor = temps.get(sensor, [])
-                if temp_sensor != []:
-                    break
-
-            core_temps = [temp.current for temp in temp_sensor]
-        except AttributeError:
-            core_temps = []
-
-        avg_temp = sum(core_temps) / len(core_temps) if core_temps else 0.0
-
-        return [
-            CoreInfo(
-                id=i,
-                usage=cpu_usage[i],
-                temperature=core_temps[i] if i < len(core_temps) else avg_temp,
-                frequency=cpu_freqs[i].current,
-            )
-            for i in range(len(cpu_usage))
-        ]
-
-    @staticmethod
-    def cpu_fan_speed() -> int | None:
-        fans = psutil.sensors_fans()
-        return next((fan[0].current for fan in fans.values() if fan), None)
-
-    @staticmethod
-    def current_gov() -> str | None:
-        try:
-            with open(
-                "/sys/devices/system/cpu/cpu0/cpufreq/scaling_governor", "r"
-            ) as f:
-                return f.read().strip()
-        except:
-            return None
-
-    @staticmethod
-    def current_epp() -> str | None:
-        epp_path = "/sys/devices/system/cpu/cpu0/cpufreq/energy_performance_preference"
-        if not Path(epp_path).exists():
-            return None
-        return config.get_config().get(
-            "battery", "energy_performance_preference", fallback="balance_power"
-        )
-
-    @staticmethod
-    def current_epb() -> str | None:
-        epb_path = "/sys/devices/system/cpu/intel_pstate"
-        if not Path(epb_path).exists():
-            return None
-        return config.get_config().get(
-            "battery", "energy_perf_bias", fallback="balance_power"
-        )
-
-    @staticmethod
-    def cpu_usage() -> float:
-        return psutil.cpu_percent(
-            interval=0.5
-        )  # Reduced interval for better responsiveness
-
-    @staticmethod
-    def system_load() -> float:
-        return os.getloadavg()[0]
-
-    @staticmethod
-    def avg_load() -> Tuple[float, float, float]:
-        return os.getloadavg()
-
-    @staticmethod
-    def avg_temp() -> int:
-        temps: List[float] = [i.temperature for i in SystemInfo.get_cpu_info()]
-        return int(sum(temps) / len(temps))
-
-    @staticmethod
-    def turbo_on() -> Tuple[bool | None, bool | None]:
-        """Get CPU turbo mode status.
-
-        Returns: Tuple[bool | None, bool | None]:
-
-        The first value indicates whether turbo mode is enabled, None if unknown
-
-        The second value indicates whether auto mode is enabled (amd_pstate only), None if unknown
-        """
-        intel_pstate = Path("/sys/devices/system/cpu/intel_pstate/no_turbo")
-        cpu_freq = Path("/sys/devices/system/cpu/cpufreq/boost")
-        amd_pstate = Path("/sys/devices/system/cpu/amd_pstate/status")
-
-        if intel_pstate.exists():
-            control_file: Path = intel_pstate
-            inverse_logic = True
-        elif cpu_freq.exists():
-            control_file = cpu_freq
-            inverse_logic = False
-        elif amd_pstate.exists():
-            amd_status: str = amd_pstate.read_text().strip()
-            if amd_status == "active":
-                return None, True
-            return None, False
-        else:
-            return None, None
-
-        try:
-            current_value = int(control_file.read_text().strip())
-            return bool(current_value) ^ inverse_logic, False
-        except Exception as e:
-            return None, None
-
-    @staticmethod
-    def battery_info() -> BatteryInfo:
-        def read_file(path: str) -> str | None:
-            try:
-                with open(path, "r") as f:
-                    return f.read().strip()
-            except FileNotFoundError:
-                return None
-
-        power_supplies: List[str] = sorted(os.listdir(POWER_SUPPLY_DIR))
-
-        if not power_supplies:
-            return BatteryInfo(
-                is_charging=None,
-                is_ac_plugged=True,
-                charging_start_threshold=None,
-                charging_stop_threshold=None,
-                battery_level=None,
-                power_consumption=None,
-            )
-
-        is_ac_plugged = None
-        is_charging = None
-        battery_level = None
-        power_consumption = None
-        charging_start_threshold = None
-        charging_stop_threshold = None
-
-        for supply in power_supplies:
-            if any(item in supply for item in get_power_supply_ignore_list()):
-                continue
-
-            supply_type: str | None = read_file(f"{POWER_SUPPLY_DIR}{supply}/type")
-
-            if supply_type == "Mains":
-                power_supply_online: str | None = read_file(
-                    f"{POWER_SUPPLY_DIR}{supply}/online"
-                )
-                is_ac_plugged = power_supply_online == "1"
-
-            elif supply_type == "Battery":
-                battery_status: str | None = read_file(
-                    f"{POWER_SUPPLY_DIR}{supply}/status"
-                )
-                battery_percentage: str | None = read_file(
-                    f"{POWER_SUPPLY_DIR}{supply}/capacity"
-                )
-                energy_rate: str | None = read_file(
-                    f"{POWER_SUPPLY_DIR}{supply}/power_now"
-                )
-                charge_start_threshold: str | None = read_file(
-                    f"{POWER_SUPPLY_DIR}{supply}/charge_start_threshold"
-                )
-                charge_stop_threshold: str | None = read_file(
-                    f"{POWER_SUPPLY_DIR}{supply}/charge_stop_threshold"
-                )
-
-                is_charging: bool | None = (
-                    battery_status.lower() == "charging" if battery_status else None
-                )
-                battery_level: int | None = (
-                    int(battery_percentage) if battery_percentage else None
-                )
-                power_consumption: float | None = (
-                    float(energy_rate) / 1_000_000 if energy_rate else None
-                )
-                charging_start_threshold: int | None = (
-                    int(charge_start_threshold) if charge_start_threshold else None
-                )
-                charging_stop_threshold: int | None = (
-                    int(charge_stop_threshold) if charge_stop_threshold else None
-                )
-
-        return BatteryInfo(
-            is_charging=is_charging,
-            is_ac_plugged=is_ac_plugged,
-            charging_start_threshold=charging_start_threshold,
-            charging_stop_threshold=charging_stop_threshold,
-            battery_level=battery_level,
-            power_consumption=power_consumption,
-        )
-
-    @staticmethod
-    def turbo_on_suggestion() -> bool:
-        usage = SystemInfo.cpu_usage()
-        if usage >= 20.0:
-            return True
-        elif usage <= 25 and SystemInfo.avg_temp() >= 70:
-            return False
-        return False
-
-    @staticmethod
-    def governor_suggestion() -> str:
-        if SystemInfo.battery_info().is_ac_plugged:
-            return AVAILABLE_GOVERNORS_SORTED[0]
-        return AVAILABLE_GOVERNORS_SORTED[-1]
-
-    def generate_system_report(self) -> SystemReport:
-        return SystemReport(
-            distro_name=self.distro_name,
-            distro_ver=self.distro_version,
-            arch=self.architecture,
-            processor_model=self.processor_model,
-            total_core=self.total_cores,
-            cpu_driver=self.cpu_driver,
-            kernel_version=self.kernel_version,
-            current_gov=self.current_gov(),
-            current_epp=self.current_epp(),
-            current_epb=self.current_epb(),
-            cpu_fan_speed=self.cpu_fan_speed(),
-            cpu_usage=self.cpu_usage(),
-            cpu_max_freq=self.cpu_max_freq(),
-            cpu_min_freq=self.cpu_min_freq(),
-            load=self.system_load(),
-            avg_load=self.avg_load(),
-            cores_info=self.get_cpu_info(),
-            is_turbo_on=self.turbo_on(),
-            battery_info=self.battery_info(),
-        )
-
-
-system_info = SystemInfo()

auto_cpufreq/modules/system_monitor.py

@@ -1,301 +0,0 @@
-import sys
-from typing import Callable
-import urwid
-import time
-from .system_info import SystemReport, system_info
-from auto_cpufreq.config.config import config
-from enum import Enum
-
-
-class ViewType(str, Enum):
-    STATS = "Stats"
-    MONITOR = "Monitor"
-    LIVE = "Live"
-
-    def __str__(self) -> str:
-        return self.value
-
-
-class SystemMonitor:
-    def __init__(self, type: ViewType, suggestion: bool = False):
-        self.type: ViewType = type
-        self.title_header = urwid.Text(f"{type} Mode", align="center")
-        self.header = urwid.Columns(
-            [
-                self.title_header,
-            ]
-        )
-
-        # Create separate content walkers for left and right columns
-        self.left_content = urwid.SimpleListWalker([])
-        self.right_content = urwid.SimpleListWalker([])
-
-        # Create listboxes for both columns
-        self.left_listbox = urwid.ListBox(self.left_content)
-        self.right_listbox = urwid.ListBox(self.right_content)
-
-        # Create a columns widget with a vertical line (using box drawing character)
-        self.columns = urwid.Columns(
-            [
-                ("weight", 1, self.left_listbox),
-                (
-                    "fixed",
-                    1,
-                    urwid.AttrMap(urwid.SolidFill("│"), "divider"),
-                ),  # Vertical line # type: ignore
-                ("weight", 1, self.right_listbox),
-            ],
-            dividechars=0,
-        )
-
-        self.footer = urwid.AttrMap(
-            urwid.Text(
-                "Press Q or Ctrl+C to quit | Use ↑↓ or PageUp/PageDown to scroll",
-                align="center",
-            ),
-            "footer",
-        )
-
-        self.frame = urwid.Frame(
-            body=self.columns,
-            header=urwid.AttrMap(self.header, "header"),
-            footer=self.footer,
-        )
-
-        palette = [
-            ("header", "white", "dark blue"),
-            ("footer", "white", "dark green"),
-            ("body", "white", "default"),
-            ("divider", "light gray", "default"),  # Style for the vertical line
-        ]
-
-        if suggestion:
-            palette.append(("suggestion", "yellow", "default"))
-
-        self.loop = urwid.MainLoop(
-            self.frame, palette=palette, unhandled_input=self.handle_input
-        )
-
-        self.last_focus_left = 0
-        self.last_focus_right = 0
-        self.on_quit: Callable[[], None] | None = None
-        self.suggestion = suggestion
-
-    def update(self, loop: urwid.MainLoop, user_data: dict) -> None:
-        # Store current focus positions
-        if len(self.left_content) > 0:
-            _, self.last_focus_left = self.left_listbox.get_focus()
-            if self.last_focus_left is None:
-                self.last_focus_left = 0
-        if len(self.right_content) > 0:
-            _, self.last_focus_right = self.right_listbox.get_focus()
-            if self.last_focus_right is None:
-                self.last_focus_right = 0
-
-        current_time = time.strftime("%H:%M:%S")
-        self.title_header.set_text(f"{self.type} Mode - {current_time}")
-
-        report: SystemReport = system_info.generate_system_report()
-        self.format_system_info(report)
-
-        # Restore focus positions
-        if len(self.left_content) > 0:
-            self.left_listbox.set_focus(min(self.last_focus_left, len(self.left_content) - 1))  # type: ignore
-        if len(self.right_content) > 0:
-            self.right_listbox.set_focus(min(self.last_focus_right, len(self.right_content) - 1))  # type: ignore
-
-        self.loop.set_alarm_in(2, self.update)  # type: ignore
-
-    def handle_input(self, key):
-        if key in ("q", "Q"):
-            if self.on_quit:
-                self.on_quit()
-            raise urwid.ExitMainLoop()
-
-    def format_system_info(self, report: SystemReport):
-        self.left_content.clear()
-        self.right_content.clear()
-
-        # Helper function to create centered text
-        def aligned_text(text: str) -> urwid.Text:
-            return urwid.Text(text, align="left")
-
-        # Left Column - System Info and CPU Stats
-        self.left_content.extend(
-            [
-                urwid.AttrMap(aligned_text("System Information"), "header"),
-                aligned_text(""),
-                aligned_text(f"Linux distro: {report.distro_name} {report.distro_ver}"),
-                aligned_text(f"Linux kernel: {report.kernel_version}"),
-                aligned_text(f"Processor: {report.processor_model}"),
-                aligned_text(f"Cores: {report.total_core}"),
-                aligned_text(f"Architecture: {report.arch}"),
-                aligned_text(f"Driver: {report.cpu_driver}"),
-                aligned_text(""),
-            ]
-        )
-
-        if config.has_config():
-            self.left_content.append(
-                aligned_text(f"Using settings defined in {config.path} file")
-            )
-            self.left_content.append(aligned_text(""))
-
-        # CPU Stats
-        self.left_content.extend(
-            [
-                urwid.AttrMap(aligned_text("Current CPU Stats"), "header"),
-                aligned_text(""),
-                aligned_text(f"CPU max frequency: {report.cpu_max_freq} MHz"),
-                aligned_text(f"CPU min frequency: {report.cpu_min_freq} MHz"),
-                aligned_text(""),
-                aligned_text("Core    Usage   Temperature     Frequency"),
-            ]
-        )
-
-        for core in report.cores_info:
-            self.left_content.append(
-                aligned_text(
-                    f"CPU{core.id:<2}    {core.usage:>4.1f}%    {core.temperature:>6.0f} °C    {core.frequency:>6.0f} MHz"
-                )
-            )
-
-        if report.cpu_fan_speed:
-            self.left_content.append(aligned_text(""))
-            self.left_content.append(
-                aligned_text(f"CPU fan speed: {report.cpu_fan_speed} RPM")
-            )
-
-        # Right Column - Battery, Frequency Scaling, and System Stats
-        if report.battery_info != None:
-            self.right_content.extend(
-                [
-                    urwid.AttrMap(aligned_text("Battery Stats"), "header"),
-                    aligned_text(""),
-                    aligned_text(f"Battery status: {str(report.battery_info)}"),
-                    aligned_text(
-                        f"Battery precentage: {(str(report.battery_info.battery_level) + '%') if report.battery_info.battery_level != None else 'Unknown'}"
-                    ),
-                    aligned_text(
-                        f'AC plugged: {("Yes" if report.battery_info.is_ac_plugged else "No") if report.battery_info.is_ac_plugged != None else "Unknown"}'
-                    ),
-                    aligned_text(
-                        f'Charging start threshold: {report.battery_info.charging_start_threshold if report.battery_info.is_ac_plugged != None else "Unknown"}'
-                    ),
-                    aligned_text(
-                        f'Charging stop threshold: {report.battery_info.charging_stop_threshold if report.battery_info.is_ac_plugged != None else "Unknown"}'
-                    ),
-                    aligned_text(""),
-                ]
-            )
-
-        # CPU Frequency Scaling
-        self.right_content.extend(
-            [
-                urwid.AttrMap(aligned_text("CPU Frequency Scaling"), "header"),
-                aligned_text(""),
-                aligned_text(
-                    f'Setting to use: "{report.current_gov if report.current_gov != None else "Unknown"}" governor'
-                ),
-            ]
-        )
-
-        if (
-            self.suggestion
-            and report.current_gov != None
-            and system_info.governor_suggestion() != report.current_gov
-        ):
-            self.right_content.append(
-                urwid.AttrMap(
-                    aligned_text(
-                        f'Suggesting use of: "{system_info.governor_suggestion()}" governor'
-                    ),
-                    "suggestion",
-                )
-            )
-
-        if report.current_epp:
-            self.right_content.append(
-                aligned_text(f"EPP setting: {report.current_epp}")
-            )
-        else:
-            self.right_content.append(
-                aligned_text("Not setting EPP (not supported by system)")
-            )
-
-        if report.current_epb:
-            self.right_content.append(
-                aligned_text(f'Setting to use: "{report.current_epb}" EPB')
-            )
-
-        self.right_content.append(aligned_text(""))
-
-        # System Statistics
-        self.right_content.extend(
-            [
-                urwid.AttrMap(aligned_text("System Statistics"), "header"),
-                aligned_text(""),
-                aligned_text(f"Total CPU usage: {report.cpu_usage:.1f} %"),
-                aligned_text(f"Total system load: {report.load:.2f}"),
-            ]
-        )
-
-        if report.cores_info:
-            avg_temp = sum(core.temperature for core in report.cores_info) / len(
-                report.cores_info
-            )
-            self.right_content.append(
-                aligned_text(f"Average temp. of all cores: {avg_temp:.2f} °C")
-            )
-
-        if report.avg_load:
-            load_status = "Load optimal" if report.load < 1.0 else "Load high"
-            self.right_content.append(
-                aligned_text(
-                    f"{load_status} (load average: {report.avg_load[0]:.2f}, {report.avg_load[1]:.2f}, {report.avg_load[2]:.2f})"
-                )
-            )
-
-        if report.cores_info:
-            usage_status = "Optimal" if report.cpu_usage < 70 else "High"
-            temp_status = "high" if avg_temp > 75 else "normal"  # type: ignore
-            self.right_content.append(
-                aligned_text(
-                    f"{usage_status} total CPU usage: {report.cpu_usage:.1f}%, {temp_status} average core temp: {avg_temp:.1f}°C"  # type: ignore
-                )
-            )
-
-        turbo_status: str
-        if report.is_turbo_on[0] != None:
-            turbo_status = "On" if report.is_turbo_on[0] else "Off"
-        elif report.is_turbo_on[1] != None:
-            turbo_status = (
-                f"Auto mode {'enabled' if report.is_turbo_on[1] else 'disabled'}"
-            )
-        else:
-            turbo_status = "Unknown"
-        self.right_content.append(aligned_text(f"Setting turbo boost: {turbo_status}"))
-        if (
-            self.suggestion
-            and report.is_turbo_on[0] != None
-            and system_info.turbo_on_suggestion() != report.is_turbo_on[0]
-        ):
-            self.right_content.append(
-                urwid.AttrMap(
-                    aligned_text(
-                        f'Suggesting to set turbo boost: {"on" if system_info.turbo_on_suggestion() else "off"}'
-                    ),
-                    "suggestion",
-                )
-            )
-
-    def run(self, on_quit: Callable[[], None] | None = None):
-        try:
-            if on_quit:
-                self.on_quit = on_quit
-            self.loop.set_alarm_in(0, self.update)  # type: ignore
-            self.loop.run()
-        except KeyboardInterrupt:
-            if on_quit:
-                on_quit()
-            sys.exit(0)

auto_cpufreq/power_helper.py

@@ -1,41 +1,49 @@
 # * add status as one of the available options
 # * alert user on snap if detected and how to remove first time live/stats message starts
 # * if daemon is disabled and auto-cpufreq is removed (snap) remind user to enable it back
-import click
+import os, sys, click
-from shutil import which
+from subprocess import getoutput, call, run, check_output, DEVNULL
-from subprocess import call, DEVNULL, getoutput, STDOUT
-from sys import argv
 
-# ToDo: update README part how to run this script
+sys.path.append("../")
 from auto_cpufreq.core import *
-from auto_cpufreq.globals import GITHUB, IS_INSTALLED_WITH_SNAP
 from auto_cpufreq.tlp_stat_parser import TLPStatusParser
 
 # app_name var
-app_name = "python3 power_helper.py" if argv[0] == "power_helper.py" else "auto-cpufreq"
+if sys.argv[0] == "power_helper.py":
+    app_name = "python3 power_helper.py"
+else:
+    app_name = "auto-cpufreq"
 
-def header(): print("\n------------------------- auto-cpufreq: Power helper -------------------------\n")
-def warning(): print("\n----------------------------------- Warning -----------------------------------\n")
 
-def helper_opts(): print("\nFor full list of options run: python3 -m auto_cpufreq.power_helper --help")
+def header():
+    print("\n------------------------- auto-cpufreq: Power helper -------------------------\n")
+
+
+def helper_opts():
+    print("\nFor full list of options run: python3 power_helper.py --help")
+
 
 # used to check if binary exists on the system
-def does_command_exists(cmd): return which(cmd) is not None
+def does_command_exists(cmd):
+    return which(cmd) is not None
+
 
-bluetoothctl_exists = does_command_exists("bluetoothctl")
-powerprofilesctl_exists = does_command_exists("powerprofilesctl")
 systemctl_exists = does_command_exists("systemctl")
+bluetoothctl_exists = does_command_exists("bluetoothctl")
 tlp_stat_exists = does_command_exists("tlp-stat")
-tuned_stat_exists = does_command_exists("tuned")
+powerprofilesctl_exists = does_command_exists("powerprofilesctl")
 
 # detect if gnome power profile service is running
-if not IS_INSTALLED_WITH_SNAP:
+if os.getenv("PKG_MARKER") != "SNAP":
     if systemctl_exists:
-        try: gnome_power_status = call(["systemctl", "is-active", "--quiet", "power-profiles-daemon"])
+        try:
+            gnome_power_status = call(
+                ["systemctl", "is-active", "--quiet", "power-profiles-daemon"]
+            )
         except:
             print("\nUnable to determine init system")
             print("If this causes any problems, please submit an issue:")
-            print(GITHUB+"/issues")
+            print("https://github.com/AdnanHodzic/auto-cpufreq/issues")
 
 # alert in case TLP service is running
 def tlp_service_detect():
@@ -43,97 +51,112 @@ def tlp_service_detect():
         status_output = getoutput("tlp-stat -s")
         tlp_status = TLPStatusParser(status_output)
         if tlp_status.is_enabled():
-            warning()
+            print(
+                "\n----------------------------------- Warning -----------------------------------\n"
+            )
             print("Detected you are running a TLP service!")
-            print("This daemon might interfere with auto-cpufreq which can lead to unexpected results.")
+            print(
-            print("We strongly encourage you to remove TLP unless you really know what you are doing.")
+                "This daemon might interfere with auto-cpufreq which can lead to unexpected results."
+            )
+            print(
+                "We strongly encourage you to remove TLP unless you really know what you are doing."
+            )
+
 
 # alert about TLP when using snap
 def tlp_service_detect_snap():
-    warning()
+    print("\n----------------------------------- Warning -----------------------------------\n")
     print("Unable to detect if you are using a TLP service!")
     print("This daemon might interfere with auto-cpufreq which can lead to unexpected results.")
     print("We strongly encourage you not to use TLP unless you really know what you are doing.")
 
+
 # alert in case gnome power profile service is running
 def gnome_power_detect():
-    if systemctl_exists and not bool(gnome_power_status):
+    if systemctl_exists:
-        warning()
+        if gnome_power_status == 0:
+            print(
+                "\n----------------------------------- Warning -----------------------------------\n"
+            )
             print("Detected running GNOME Power Profiles daemon service!")
-        print("\nThis daemon might interfere with auto-cpufreq and will be automatically")
+            print("This daemon might interfere with auto-cpufreq and should be disabled.")
-        print("disabled when auto-cpufreq daemon is installed and")
+            print("\nSteps to perform this action using auto-cpufreq: power_helper script:")
-        print("it will be re-enabled after auto-cpufreq is removed.")
+            print("git clone https://github.com/AdnanHodzic/auto-cpufreq.git")
+            print("cd auto-cpufreq/auto_cpufreq")
+            print("python3 power_helper.py --gnome_power_disable")
 
-        print("\nOnly necessary to be manually done on Snap package installs!")
-        print("Steps to perform this action using auto-cpufreq: power_helper script:")
-        print(f"git clone {GITHUB}.git")
-        print("python3 -m auto_cpufreq.power_helper --gnome_power_disable")
-        print(f"\nReference: {GITHUB}#configuring-auto-cpufreq")
 
 # automatically disable gnome power profile service in case it's running during install
 def gnome_power_detect_install():
-    if systemctl_exists and not bool(gnome_power_status):
+    if systemctl_exists:
-        warning()
+        if gnome_power_status == 0:
+            print(
+                "\n----------------------------------- Warning -----------------------------------\n"
+            )
             print("Detected running GNOME Power Profiles daemon service!")
-        print("\nThis daemon might interfere with auto-cpufreq and has been disabled.\n")
+            print("This daemon might interfere with auto-cpufreq and has been disabled.\n")
             print('This daemon is not automatically disabled in "monitor" mode and')
-        print("will be enabled after auto-cpufreq daemon is removed.")
+            print("will be enabled after auto-cpufreq is removed.")
 
 
 # notification on snap
 def gnome_power_detect_snap():
-    warning()
+    print("\n----------------------------------- Warning -----------------------------------\n")
-    print("Due to Snap package confinement limitations please consider installing auto-cpufreq using")
-    print(f"auto-cpufreq-installer: {GITHUB}#auto-cpufreq-installer")
-    print()
     print("Unable to detect state of GNOME Power Profiles daemon service!")
-    print("This daemon might interfere with auto-cpufreq and should be disabled!")
+    print("This daemon might interfere with auto-cpufreq and should be disabled.")
     print("\nSteps to perform this action using auto-cpufreq: power_helper script:")
-    print(f"git clone {GITHUB}.git")
+    print("git clone https://github.com/AdnanHodzic/auto-cpufreq.git")
-    print("python3 -m auto_cpufreq.power_helper --gnome_power_disable")
+    print("cd auto-cpufreq/auto_cpufreq")
-    print(f"\nReference: {GITHUB}#configuring-auto-cpufreq")
+    print("python3 power_helper.py --gnome_power_disable")
+
 
 # stops gnome >= 40 power profiles (live)
 def gnome_power_stop_live():
-    if systemctl_exists and not bool(gnome_power_status) and powerprofilesctl_exists:
+    if systemctl_exists:
+        if gnome_power_status == 0 and powerprofilesctl_exists:
             call(["powerprofilesctl", "set", "balanced"])
             call(["systemctl", "stop", "power-profiles-daemon"])
 
-# stops tuned (live)
-def tuned_stop_live():
-    if systemctl_exists and tuned_stat_exists:
-        call(["systemctl", "stop", "tuned"])
-
 # starts gnome >= 40 power profiles (live)
 def gnome_power_start_live():
-    if systemctl_exists: call(["systemctl", "start", "power-profiles-daemon"])
+    if systemctl_exists:
+        call(["systemctl", "start", "power-profiles-daemon"])
+
+
+# disable gnome >= 40 power profiles (install)
+def gnome_power_svc_disable():
+    if systemctl_exists:
+        # set balanced profile if its running before disabling it
+        if gnome_power_status == 0 and powerprofilesctl_exists:
+            call(["powerprofilesctl", "set", "balanced"])
+
+        # always disable power-profiles-daemon
+        try:
+            print("\n* Disabling GNOME power profiles")
+            call(["systemctl", "stop", "power-profiles-daemon"])
+            call(["systemctl", "disable", "power-profiles-daemon"])
+            call(["systemctl", "mask", "power-profiles-daemon"])
+            call(["systemctl", "daemon-reload"])
+        except:
+            print("\nUnable to disable GNOME power profiles")
+            print("If this causes any problems, please submit an issue:")
+            print("https://github.com/AdnanHodzic/auto-cpufreq/issues")
 
-def tuned_start_live():
-    if systemctl_exists and tuned_stat_exists: 
-        call(["systemctl", "start", "tuned"])
 
 # enable gnome >= 40 power profiles (uninstall)
 def gnome_power_svc_enable():
     if systemctl_exists:
         try:
-            print("* Enabling GNOME power profiles\n")
+            print("\n* Enabling GNOME power profiles")
             call(["systemctl", "unmask", "power-profiles-daemon"])
-            call(["systemctl", "enable", "--now", "power-profiles-daemon"])
+            call(["systemctl", "start", "power-profiles-daemon"])
+            call(["systemctl", "enable", "power-profiles-daemon"])
+            call(["systemctl", "daemon-reload"])
         except:
             print("\nUnable to enable GNOME power profiles")
             print("If this causes any problems, please submit an issue:")
-            print(GITHUB+"/issues")
+            print("https://github.com/AdnanHodzic/auto-cpufreq/issues")
 
-def tuned_svc_enable():
-    if systemctl_exists and tuned_stat_exists:
-        try:
-            print("* Enabling TuneD\n")
-            call(["systemctl", "unmask", "tuned"])
-            call(["systemctl", "enable", "--now", "tuned"])
-        except:
-            print("\nUnable to enable TuneD daemon")
-            print("If this causes any problems, please submit an issue:")
-            print(GITHUB+"/issues")
 
 # gnome power profiles current status
 def gnome_power_svc_status():
@@ -144,14 +167,15 @@ def gnome_power_svc_status():
         except:
             print("\nUnable to see GNOME power profiles status")
             print("If this causes any problems, please submit an issue:")
-            print(GITHUB+"/issues")
+            print("https://github.com/AdnanHodzic/auto-cpufreq/issues")
+
 
 # disable bluetooth on boot
 def bluetooth_disable():
-    if IS_INSTALLED_WITH_SNAP: bluetooth_notif_snap()
+    if os.getenv("PKG_MARKER") == "SNAP":
+        bluetooth_notif_snap()
     elif bluetoothctl_exists:
-        print("* Turn off Bluetooth on boot (only)!")
+        print("* Turn off bluetooth on boot")
-        print("  If you want bluetooth enabled on boot run: auto-cpufreq --bluetooth_boot_on")
         btconf = Path("/etc/bluetooth/main.conf")
         try:
             orig_set = "AutoEnable=true"
@@ -161,12 +185,18 @@ def bluetooth_disable():
                 f.seek(0)
                 f.truncate()
                 f.write(content.replace(orig_set, change_set))
-        except Exception as e: print(f"\nERROR:\nWas unable to turn off bluetooth on boot\n{repr(e)}")
+        except Exception as e:
-    else: print("* Turn off bluetooth on boot [skipping] (package providing bluetooth access is not present)")
+            print(f"\nERROR:\nWas unable to turn off bluetooth on boot\n{repr(e)}")
+    else:
+        print(
+            "* Turn off bluetooth on boot [skipping] (package providing bluetooth access is not present)"
+        )
+
 
 # enable bluetooth on boot
 def bluetooth_enable():
-    if IS_INSTALLED_WITH_SNAP: bluetooth_on_notif_snap()
+    if os.getenv("PKG_MARKER") == "SNAP":
+        bluetooth_on_notif_snap()
     if bluetoothctl_exists:
         print("* Turn on bluetooth on boot")
         btconf = "/etc/bluetooth/main.conf"
@@ -178,115 +208,61 @@ def bluetooth_enable():
                 f.seek(0)
                 f.truncate()
                 f.write(content.replace(change_set, orig_set))
-        except Exception as e: print(f"\nERROR:\nWas unable to turn on bluetooth on boot\n{repr(e)}")
+        except Exception as e:
-    else: print("* Turn on bluetooth on boot [skipping] (package providing bluetooth access is not present)")
+            print(f"\nERROR:\nWas unable to turn on bluetooth on boot\n{repr(e)}")
+    else:
+        print(
+            "* Turn on bluetooth on boot [skipping] (package providing bluetooth access is not present)"
+        )
+
 
 # turn off bluetooth on snap message
 def bluetooth_notif_snap():
     print("\n* Unable to turn off bluetooth on boot due to Snap package restrictions!")
     print("\nSteps to perform this action using auto-cpufreq: power_helper script:")
-    print("python3 -m auto_cpufreq.power_helper --bluetooth_boot_off")
+    print("python3 power_helper.py --bluetooth_boot_off")
-    print("\nFor help see: https://github.com/AdnanHodzic/auto-cpufreq/#1-power_helperpy-script-snap-package-install-only")
+
 
 # turn off bluetooth on snap message
 def bluetooth_on_notif_snap():
     print("\n* Unable to turn on bluetooth on boot due to Snap package restrictions!")
     print("\nSteps to perform this action using auto-cpufreq: power_helper script:")
-    print("python3 -m auto_cpufreq.power_helper --bluetooth_boot_on")
+    print("python3 power_helper.py --bluetooth_boot_on")
-    print("\nFor help see: https://github.com/AdnanHodzic/auto-cpufreq/#1-power_helperpy-script-snap-package-install-only")
+
 
 # gnome power removal reminder
 def gnome_power_rm_reminder():
-    if systemctl_exists and bool(gnome_power_status):
+    if systemctl_exists:
-        warning()
+        if gnome_power_status != 0:
+            print(
+                "\n----------------------------------- Warning -----------------------------------\n"
+            )
             print("Detected GNOME Power Profiles daemon service is stopped!")
-        print("This service will now be enabled and started again.\n")
+            print("This service will now be enabled and started again.")
 
 
 def gnome_power_rm_reminder_snap():
-    warning()
+    print("\n----------------------------------- Warning -----------------------------------\n")
     print("Unable to detect state of GNOME Power Profiles daemon service!")
     print("Now it's recommended to enable this service.")
     print("\nSteps to perform this action using auto-cpufreq: power_helper script:")
-    print(f"git clone {GITHUB}.git")
+    print("git clone https://github.com/AdnanHodzic/auto-cpufreq.git")
-    print("python3 -m auto_cpufreq.power_helper --gnome_power_enable")
+    print("cd auto-cpufreq/auto_cpufreq")
-    print(f"\nReference: {GITHUB}#configuring-auto-cpufreq")
+    print("python3 power_helper.py --gnome_power_enable")
+
 
 def valid_options():
     print("--gnome_power_enable\t\tEnable GNOME Power Profiles daemon")
     print("--gnome_power_disable\t\tDisable GNOME Power Profiles daemon\n")
 
-def disable_power_profiles_daemon():
-    # always disable power-profiles-daemon
-    try:
-        print("\n* Disabling GNOME power profiles")
-        call(["systemctl", "disable", "--now", "power-profiles-daemon"])
-        call(["systemctl", "mask", "power-profiles-daemon"])
-    except:
-        print("\nUnable to disable GNOME power profiles")
-        print("If this causes any problems, please submit an issue:")
-        print(GITHUB+"/issues")
-
-def disable_tuned_daemon():
-    # always disable TuneD daemon
-    try:
-        print("\n* Disabling TuneD daemon")
-        call(["systemctl", "disable", "--now", "tuned"])
-        call(["systemctl", "mask", "tuned"])
-    except:
-        print("\nUnable to disable TuneD daemon")
-        print("If this causes any problems, please submit an issue:")
-        print(GITHUB+"/issues")
-
-# default gnome_power_svc_disable func (balanced)
-def gnome_power_svc_disable():
-    snap_pkg_check = 0
-    if systemctl_exists:
-        if bool(gnome_power_status):
-            try:
-                # check if snap package installed
-                snap_pkg_check = call(['snap', 'list', '|', 'grep', 'auto-cpufreq'], 
-                stdout=DEVNULL,
-                stderr=STDOUT)
-                # check if snapd is present and if snap package is installed | 0 is success
-                if not bool(snap_pkg_check):
-                    print("GNOME Power Profiles Daemon is already disabled, it can be re-enabled by running:\n"
-                        "sudo python3 -m auto_cpufreq.power_helper --gnome_power_enable\n"
-                    )
-                elif snap_pkg_check == 1:
-                    print("auto-cpufreq snap package not installed\nGNOME Power Profiles Daemon should be enabled. run:\n\n"
-                        "sudo python3 -m auto_cpufreq.power_helper --gnome_power_enable"
-                    )
-            except:
-                # snapd not found on the system
-                print("There was a problem, couldn't determine GNOME Power Profiles Daemon")
-                snap_pkg_check = 0
-
-        if not bool(gnome_power_status) and powerprofilesctl_exists:
-            if snap_pkg_check == 1:
-                print("auto-cpufreq snap package not installed.\nGNOME Power Profiles Daemon should be enabled, run:\n\n"
-                    "sudo python3 -m auto_cpufreq.power_helper --gnome_power_enable"
-                )
-            else:
-                print("auto-cpufreq snap package installed, GNOME Power Profiles Daemon should be disabled.\n")
-                print("Using profile: ", "balanced")
-                call(["powerprofilesctl", "set", "balanced"])
-
-                disable_power_profiles_daemon()
-
-def tuned_svc_disable():
-    if systemctl_exists and tuned_stat_exists:
-        disable_tuned_daemon()
 
 # cli
 @click.command()
-#@click.option("--gnome_power_disable", help="Disable GNOME Power profiles service (default: balanced), reference:\n https://bit.ly/3bjVZW1", type=click.Choice(['balanced', 'performance'], case_sensitive=False))
-@click.option("--gnome_power_disable", is_flag=True, help="Disable GNOME Power profiles service")
-# ToDo:
-# * update readme/docs
 @click.option("--gnome_power_enable", is_flag=True, help="Enable GNOME Power profiles service")
-
+@click.option("--gnome_power_disable", is_flag=True, help="Disable GNOME Power profiles service")
-@click.option("--gnome_power_status", is_flag=True, help="Get status of GNOME Power profiles service")
+@click.option(
+    "--gnome_power_status", is_flag=True, help="Get status of GNOME Power profiles service"
+)
 @click.option("--bluetooth_boot_on", is_flag=True, help="Turn on Bluetooth on boot")
 @click.option("--bluetooth_boot_off", is_flag=True, help="Turn off Bluetooth on boot")
 def main(
@@ -296,18 +272,46 @@ def main(
     bluetooth_boot_off,
     bluetooth_boot_on,
 ):
+
     root_check()
+    if len(sys.argv) == 1:
         header()
-
+        print(
-    if len(argv) == 1: print('Unrecognized option!\n\nRun: "' + app_name + ' --help" for list of available options.')
+            'Unrecognized option!\n\nRun: "' + app_name + ' --help" for list of available options.'
+        )
+        footer()
     else:
-        if gnome_power_enable: gnome_power_svc_enable()
+        if gnome_power_enable:
-        elif gnome_power_disable: gnome_power_svc_disable()
+            header()
-        elif gnome_power_status: gnome_power_svc_status()
+            root_check()
-        elif bluetooth_boot_off: bluetooth_disable()
+            gnome_power_svc_enable()
-        elif bluetooth_boot_on: bluetooth_enable()
+            helper_opts()
+            footer()
+        elif gnome_power_disable:
+            header()
+            root_check()
+            gnome_power_svc_disable()
+            helper_opts()
+            footer()
+        elif gnome_power_status:
+            header()
+            root_check()
+            gnome_power_svc_status()
+            helper_opts()
+            footer()
+        elif bluetooth_boot_off:
+            header()
+            root_check()
+            bluetooth_disable()
+            helper_opts()
+            footer()
+        elif bluetooth_boot_on:
+            header()
+            root_check()
+            bluetooth_enable()
             helper_opts()
-
             footer()
 
-if __name__ == "__main__": main()
+
+if __name__ == "__main__":
+    main()

auto_cpufreq/tlp_stat_parser.py

@@ -6,8 +6,14 @@ class TLPStatusParser:
     def _parse(self, data):
         for line in data.split("\n"):
             key_val = line.split("=", 1)
-            if len(key_val) > 1: self.data[key_val[0].strip().lower()] = key_val[1].strip()
+            if len(key_val) > 1:
+                self.data[key_val[0].strip().lower()] = key_val[1].strip()
 
-    def _get_key(self, key): return self.data[key] if key in self.data else ""
+    def _get_key(self, key):
+        if key in self.data:
+            return self.data[key]
+        else:
+            return ""
 
-    def is_enabled(self): return self._get_key("state") == "enabled"
+    def is_enabled(self):
+        return self._get_key("state") == "enabled"

bin/auto-cpufreq

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+#
+# auto-cpufreq - Automatic CPU speed & power optimizer for Linux
+#
+# Blog post: https://foolcontrol.org/?p=3124
+
+# core import
+import sys
+import time
+import click
+from subprocess import call, run
+
+sys.path.append("../")
+from auto_cpufreq.core import *
+from auto_cpufreq.power_helper import *
+
+# cli
+@click.command()
+@click.option("--monitor", is_flag=True, help="Monitor and see suggestions for CPU optimizations")
+@click.option("--live", is_flag=True, help="Monitor and make (temp.) suggested CPU optimizations")
+@click.option(
+    "--install/--remove",
+    default=True,
+    help="Install/remove daemon for (permanent) automatic CPU optimizations",
+)
+@click.option("--stats", is_flag=True, help="View live stats of CPU optimizations made by daemon")
+@click.option(
+    "--config",
+    is_flag=False,
+    default="/etc/auto-cpufreq.conf",
+    help="Use config file at defined path",
+)
+@click.option("--debug", is_flag=True, help="Show debug info (include when submitting bugs)")
+@click.option("--version", is_flag=True, help="Show currently installed version")
+@click.option("--donate", is_flag=True, help="Support the project")
+@click.option("--log", is_flag=True, hidden=True)
+@click.option("--daemon", is_flag=True, hidden=True)
+def main(config, daemon, debug, install, live, log, monitor, stats, version, donate):
+
+    # display info if config file is used
+    def config_info_dialog():
+        if get_config(config) and hasattr(get_config, "using_cfg_file"):
+            print("\nUsing settings defined in " + config + " file")
+
+    if len(sys.argv) == 1:
+        print("\n" + "-" * 32 + " auto-cpufreq " + "-" * 33 + "\n")
+        print("Automatic CPU speed & power optimizer for Linux")
+        print("\nExample usage:\nauto-cpufreq --monitor")
+        print("\n-----\n")
+
+        run(["auto-cpufreq", "--help"])
+        footer()
+    else:
+        if daemon:
+            config_info_dialog()
+            root_check()
+            file_stats()
+            if os.getenv("PKG_MARKER") == "SNAP" and dcheck == "enabled":
+                gnome_power_detect_snap()
+                tlp_service_detect_snap()
+                while True:
+                    footer()
+                    gov_check()
+                    cpufreqctl()
+                    distro_info()
+                    sysinfo()
+                    set_autofreq()
+                    countdown(5)
+            elif os.getenv("PKG_MARKER") != "SNAP":
+                gnome_power_detect()
+                tlp_service_detect()
+                while True:
+                    footer()
+                    gov_check()
+                    cpufreqctl()
+                    distro_info()
+                    sysinfo()
+                    set_autofreq()
+                    countdown(5)
+            else:
+                daemon_not_found()
+        elif monitor:
+            config_info_dialog()
+            root_check()
+            print('\nNote: You can quit monitor mode by pressing "ctrl+c"')
+            if os.getenv("PKG_MARKER") == "SNAP":
+                gnome_power_detect_snap()
+                tlp_service_detect_snap()
+            else:
+                gnome_power_detect()
+                tlp_service_detect()
+            while True:
+                time.sleep(1)
+                running_daemon()
+                footer()
+                gov_check()
+                cpufreqctl()
+                distro_info()
+                sysinfo()
+                mon_autofreq()
+                countdown(5)
+        elif live:
+            root_check()
+            config_info_dialog()
+            print('\nNote: You can quit live mode by pressing "ctrl+c"')
+            time.sleep(1)
+            if os.getenv("PKG_MARKER") == "SNAP":
+                gnome_power_detect_snap()
+                tlp_service_detect_snap()
+            else:
+                gnome_power_detect_install()
+                gnome_power_stop_live()
+                tlp_service_detect()
+            while True:
+                try:
+                    running_daemon()
+                    footer()
+                    gov_check()
+                    cpufreqctl()
+                    distro_info()
+                    sysinfo()
+                    set_autofreq()
+                    countdown(5)
+                except KeyboardInterrupt:
+                    gnome_power_start_live()
+                    print("")
+                    sys.exit()
+        elif stats:
+            config_info_dialog()
+            print('\nNote: You can quit stats mode by pressing "ctrl+c"')
+            if os.getenv("PKG_MARKER") == "SNAP":
+                gnome_power_detect_snap()
+                tlp_service_detect_snap()
+            else:
+                gnome_power_detect()
+                tlp_service_detect()
+            time.sleep(1)
+            read_stats()
+        elif log:
+            deprecated_log_msg()
+        elif debug:
+            # ToDo: add status of GNOME Power Profile servie status
+            config_info_dialog()
+            root_check()
+            cpufreqctl()
+            footer()
+            distro_info()
+            sysinfo()
+            print("")
+            app_version()
+            print("")
+            python_info()
+            print("")
+            device_info()
+            if charging():
+                print("Battery is: charging")
+            else:
+                print("Battery is: discharging")
+            print("")
+            app_res_use()
+            display_load()
+            get_current_gov()
+            get_turbo()
+            footer()
+        elif version:
+            footer()
+            distro_info()
+            app_version()
+            footer()
+        elif donate:
+            footer()
+            print("If auto-cpufreq helped you out and you find it useful ...\n")
+            print("Show your appreciation by donating!")
+            print("https://github.com/AdnanHodzic/auto-cpufreq/#donate")
+            footer()
+        elif install:
+            if os.getenv("PKG_MARKER") == "SNAP":
+                root_check()
+                running_daemon()
+                gnome_power_detect_snap()
+                tlp_service_detect_snap()
+                bluetooth_notif_snap()
+                gov_check()
+                run("snapctl set daemon=enabled", shell=True)
+                run("snapctl start --enable auto-cpufreq", shell=True)
+                deploy_complete_msg()
+            else:
+                root_check()
+                running_daemon()
+                gov_check()
+                deploy_daemon()
+                deploy_complete_msg()
+        elif remove:
+            if os.getenv("PKG_MARKER") == "SNAP":
+                root_check()
+                run("snapctl set daemon=disabled", shell=True)
+                run("snapctl stop --disable auto-cpufreq", shell=True)
+                if auto_cpufreq_stats_path.exists():
+                    if auto_cpufreq_stats_file is not None:
+                        auto_cpufreq_stats_file.close()
+
+                    auto_cpufreq_stats_path.unlink()
+                # ToDo:
+                # * undo bluetooth boot disable
+                gnome_power_rm_reminder_snap()
+                remove_complete_msg()
+            else:
+                root_check()
+                remove()
+                remove_complete_msg()
+
+
+if __name__ == "__main__":
+    main()

flake.lock

@@ -1,27 +0,0 @@
-{
-  "nodes": {
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1740547748,
-        "narHash": "sha256-Ly2fBL1LscV+KyCqPRufUBuiw+zmWrlJzpWOWbahplg=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "3a05eebede89661660945da1f151959900903b6a",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "nixpkgs": "nixpkgs"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

flake.nix

@@ -1,24 +0,0 @@
-{
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
-  };
-
-  outputs = {nixpkgs, ...} @ inputs: let
-    forAllSystems = nixpkgs.lib.genAttrs ["x86_64-linux" "i686-linux" "aarch64-linux"];
-    pkgsForEach = nixpkgs.legacyPackages;
-  in {
-    packages = forAllSystems (system: {
-      default = pkgsForEach.${system}.callPackage ./nix/default.nix {};
-    });
-
-    devShells = forAllSystems (system: {
-      default = pkgsForEach.${system}.callPackage ./nix/shell.nix {};
-    });
-
-    overlays.default = final: _: {
-      auto-cpufreq = final.callPackage ./nix/default.nix {};
-    };
-
-    nixosModules.default = import ./nix/module.nix inputs;
-  };
-}

nix/default.nix

@@ -1,82 +0,0 @@
-{
-  lib,
-  python3Packages,
-  pkgs,
-  fetchFromGitHub,
-  fetchPypi,
-}:
-let
-
-  pyinotify = python3Packages.pyinotify.overrideAttrs (oldAttrs: {
-    src = fetchFromGitHub {
-      owner = "shadeyg56";
-      repo = "pyinotify-3.12";
-      rev = "923cebec3a2a84c7e38c9e68171eb93f5d07ce5d";
-      hash = "sha256-714CximEK4YhIqDmvqJYOUGs39gvDkWGrkNrXwxT8iM=";
-    };
-    patches = [];
-  });
-
-in
-python3Packages.buildPythonPackage {
-  # use pyproject.toml instead of setup.py
-  format = "pyproject";
-
-  pname = "auto-cpufreq";
-  version = "2.6.0";
-  src = ../.;
-
-  nativeBuildInputs = with pkgs; [wrapGAppsHook gobject-introspection];
-
-  buildInputs = with pkgs; [gtk3 python3Packages.poetry-core];
-
-  propagatedBuildInputs = with python3Packages; [requests pygobject3 click distro psutil setuptools poetry-dynamic-versioning pyinotify urwid pyasyncore pkgs.getent];  
-
-  doCheck = false;
-  pythonImportsCheck = ["auto_cpufreq"];
-
-  patches = [
-    # patch to prevent script copying and to disable install
-    ./patches/prevent-install-and-copy.patch
-  ];
-
-  postPatch = ''
-    substituteInPlace auto_cpufreq/core.py --replace-fail '/opt/auto-cpufreq/override.pickle' /var/run/override.pickle
-    substituteInPlace scripts/org.auto-cpufreq.pkexec.policy --replace-fail "/opt/auto-cpufreq/venv/bin/auto-cpufreq" $out/bin/auto-cpufreq
-
-    substituteInPlace auto_cpufreq/gui/app.py auto_cpufreq/gui/objects.py --replace-fail "/usr/local/share/auto-cpufreq/images/icon.png" $out/share/pixmaps/auto-cpufreq.png
-    substituteInPlace auto_cpufreq/gui/app.py --replace-fail "/usr/local/share/auto-cpufreq/scripts/style.css" $out/share/auto-cpufreq/scripts/style.css
-  '';
-
-  postInstall = ''
-    # copy script manually
-    cp scripts/cpufreqctl.sh $out/bin/cpufreqctl.auto-cpufreq
-
-    # move the css to the right place
-    mkdir -p $out/share/auto-cpufreq/scripts
-    cp scripts/style.css $out/share/auto-cpufreq/scripts/style.css
-
-    # systemd service
-    mkdir -p $out/lib/systemd/system
-    cp scripts/auto-cpufreq.service $out/lib/systemd/system
-
-    # desktop icon
-    mkdir -p $out/share/applications
-    mkdir $out/share/pixmaps
-    cp scripts/auto-cpufreq-gtk.desktop $out/share/applications
-    cp images/icon.png $out/share/pixmaps/auto-cpufreq.png
-
-    # polkit policy
-    mkdir -p $out/share/polkit-1/actions
-    cp scripts/org.auto-cpufreq.pkexec.policy $out/share/polkit-1/actions
-  '';
-
-  meta = {
-    homepage = "https://github.com/AdnanHodzic/auto-cpufreq";
-    description = "Automatic CPU speed & power optimizer for Linux";
-    license = lib.licenses.lgpl3Plus;
-    platforms = lib.platforms.linux;
-    maintainers = with lib.maintainers; [Technical27];
-    mainProgram = "auto-cpufreq";
-  };
-}

nix/module.nix

@@ -1,64 +0,0 @@
-inputs: {
-  config,
-  lib,
-  pkgs,
-  ...
-}:
-let
-  cfg = config.programs.auto-cpufreq;
-  inherit (pkgs.stdenv.hostPlatform) system;
-  defaultPackage = inputs.self.packages.${system}.default;
-  cfgFilename = "auto-cpufreq.conf";
-  cfgFile = format.generate cfgFilename cfg.settings;
-
-  inherit (lib) types;
-  inherit (lib.modules) mkIf mkForce;
-  inherit (lib.options) mkOption mkEnableOption;
-
-  format = pkgs.formats.ini {};
-in {
-  options.programs.auto-cpufreq = {
-    enable = mkEnableOption "Automatic CPU speed & power optimizer for Linux";
-
-    settings = mkOption {
-      description = ''
-        Configuration for `auto-cpufreq`.
-
-        See its [example configuration file] for supported settings.
-        [example configuration file]: https://github.com/AdnanHodzic/auto-cpufreq/blob/master/auto-cpufreq.conf-example
-      '';
-
-      default = {};
-      type = types.submodule {freeformType = format.type;};
-    };
-  };
-
-  config = mkIf cfg.enable {
-    environment.systemPackages = [ defaultPackage ];
-
-    systemd = {
-      packages =  [ defaultPackage ];
-      services.auto-cpufreq = {
-        wantedBy = [ "multi-user.target" ];
-        path = with pkgs; [ bash coreutils ];
-        overrideStrategy = "asDropin";
-
-        serviceConfig.WorkingDirectory = "";
-        serviceConfig.ExecStart = mkForce [
-          ""
-          "${defaultPackage}/bin/auto-cpufreq --daemon --config ${cfgFile}"
-        ];
-      };
-    };
-
-    assertions = [
-      {
-        assertion = !config.services.power-profiles-daemon.enable;
-        message = ''
-          You have set services.power-profiles-daemon.enable = true;
-          which conflicts with auto-cpufreq
-        '';
-      }
-    ];
-  };
-}

nix/patches/prevent-install-and-copy.patch

@@ -1,101 +0,0 @@
-diff --git a/auto_cpufreq/core.py b/auto_cpufreq/core.py
-index f03e7de..2dff5fb 100755
---- a/auto_cpufreq/core.py
-+++ b/auto_cpufreq/core.py
-@@ -277,19 +277,12 @@ def get_current_gov():
-     )
- 
- def cpufreqctl():
--    """
--    deploy cpufreqctl.auto-cpufreq script
--    """
--    if not (IS_INSTALLED_WITH_SNAP or os.path.isfile("/usr/local/bin/cpufreqctl.auto-cpufreq")):
--        copy(SCRIPTS_DIR / "cpufreqctl.sh", "/usr/local/bin/cpufreqctl.auto-cpufreq")
--        call(["chmod", "a+x", "/usr/local/bin/cpufreqctl.auto-cpufreq"])
-+    # scripts are already in the correct place
-+    pass
- 
- def cpufreqctl_restore():
--    """
--    remove cpufreqctl.auto-cpufreq script
--    """
--    if not IS_INSTALLED_WITH_SNAP and os.path.isfile("/usr/local/bin/cpufreqctl.auto-cpufreq"):
--        os.remove("/usr/local/bin/cpufreqctl.auto-cpufreq")
-+    #no need to restore
-+    pass
- 
- def footer(l=79): print("\n" + "-" * l + "\n")
- 
-@@ -307,31 +300,8 @@ def remove_complete_msg():
-     footer()
- 
- def deploy_daemon():
--    print("\n" + "-" * 21 + " Deploying auto-cpufreq as a daemon " + "-" * 22 + "\n")
--
--    cpufreqctl() # deploy cpufreqctl script func call
--
--    bluetooth_disable() # turn off bluetooth on boot
--
--    auto_cpufreq_stats_path.touch(exist_ok=True)
--
--    print("\n* Deploy auto-cpufreq install script")
--    copy(SCRIPTS_DIR / "auto-cpufreq-install.sh", "/usr/local/bin/auto-cpufreq-install")
--    call(["chmod", "a+x", "/usr/local/bin/auto-cpufreq-install"])
--
--    print("\n* Deploy auto-cpufreq remove script")
--    copy(SCRIPTS_DIR / "auto-cpufreq-remove.sh", "/usr/local/bin/auto-cpufreq-remove")
--    call(["chmod", "a+x", "/usr/local/bin/auto-cpufreq-remove"])
--
--    # output warning if gnome power profile is running
--    gnome_power_detect_install()
--    gnome_power_svc_disable()
--
--    tuned_svc_disable()
--
--    tlp_service_detect() # output warning if TLP service is detected
--
--    call("/usr/local/bin/auto-cpufreq-install", shell=True)
-+    # prevent needless copying and system changes
-+    pass
- 
- def deploy_daemon_performance():
-     print("\n" + "-" * 21 + " Deploying auto-cpufreq as a daemon (performance) " + "-" * 22 + "\n")
-@@ -363,37 +333,7 @@ def deploy_daemon_performance():
- 
-     call("/usr/local/bin/auto-cpufreq-install", shell=True)
- 
--def remove_daemon():
--    # check if auto-cpufreq is installed
--    if not os.path.exists("/usr/local/bin/auto-cpufreq-remove"):
--        print("\nauto-cpufreq daemon is not installed.\n")
--        sys.exit(1)
--
--    print("\n" + "-" * 21 + " Removing auto-cpufreq daemon " + "-" * 22 + "\n")
--
--    bluetooth_enable() # turn on bluetooth on boot
--
--    # output warning if gnome power profile is stopped
--    gnome_power_rm_reminder()
--    gnome_power_svc_enable()
--
--    tuned_svc_enable()
--
--    # run auto-cpufreq daemon remove script
--    call("/usr/local/bin/auto-cpufreq-remove", shell=True)
--
--    # remove auto-cpufreq-remove
--    os.remove("/usr/local/bin/auto-cpufreq-remove")
--
--    # delete override pickle if it exists
--    if os.path.exists(governor_override_state):  os.remove(governor_override_state)
--
--    # delete stats file
--    if auto_cpufreq_stats_path.exists():
--        if auto_cpufreq_stats_file is not None: auto_cpufreq_stats_file.close()
--        auto_cpufreq_stats_path.unlink()
--
--    cpufreqctl_restore() # restore original cpufrectl script
-+def remove_daemon(): pass
- 
- def gov_check():
-     for gov in AVAILABLE_GOVERNORS:

nix/shell.nix

@@ -1,15 +0,0 @@
-{
-  python3Packages,
-  pkgs,
-  ...
-}: let
-  mainPkg = python3Packages.callPackage ./default.nix {};
-in
-  mainPkg.overrideAttrs (oa: {
-    nativeBuildInputs =
-      [
-        python3Packages.pip
-        pkgs.poetry
-      ]
-      ++ (oa.nativeBuildInputs or []);
-  })

pyproject.toml

@@ -1,54 +0,0 @@
-[tool.poetry]
-name = "auto-cpufreq"
-version = "2.6.0"
-description = "Automatic CPU speed & power optimizer for Linux"
-authors = ["Adnan Hodzic <adnan@hodzic.org>"]
-license = "GPL-3.0-or-later"
-readme = "README.md"
-classifiers=[
-    "Development Status :: 5 - Production/Stable",
-    "Intended Audience :: Developers",
-    "Operating System :: POSIX :: Linux",
-    "Environment :: Console",
-    "Natural Language :: English"
-]
-keywords=["linux", "cpu", "speed", "power", "frequency", "turbo", "optimzier", "auto", "cpufreq"]
-repository = "https://github.com/AdnanHodzic/auto-cpufreq"
-documentation = "https://github.com/AdnanHodzic/auto-cpufreq#readme"
-packages = [
-    { include = "./auto_cpufreq" },
-    { include = "./auto_cpufreq/gui" },
-]
-
-[tool.poetry.dependencies]
-python = ">=3.9, <4.0"
-psutil = ">=6.0.0,<8.0.0"
-click = "^8.1.0"
-distro = "^1.8.0"
-requests = "^2.32.3"
-# PyObject version will be updated automatically for Debian based distro based on libgirepository 
-# apt package version: https://github.com/AdnanHodzic/auto-cpufreq/pull/826#issuecomment-2794549837
-PyGObject = {version="3.50.0", optional=true}
-urwid = "^2.6.16"
-pyinotify = {git = "https://github.com/shadeyg56/pyinotify-3.12"}
-pyasyncore = "^1.0.4"
-
-[tool.poetry.group.dev.dependencies]
-poetry = "^1.6.1"
-
-[build-system]
-requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
-build-backend = "poetry_dynamic_versioning.backend"
-
-[tool.poetry.scripts]
-auto-cpufreq = "auto_cpufreq.bin.auto_cpufreq:main"
-auto-cpufreq-gtk = "auto_cpufreq.bin.auto_cpufreq_gtk:main"
-
-# https://github.com/mtkennerly/poetry-dynamic-versioning
-[tool.poetry-dynamic-versioning]
-enable = true
-vcs = "git"
-format = "v{base}+{commit}"
-
-# SideNote
-# Regarding zip_safe = https://setuptools.pypa.io/en/latest/deprecated/zip_safe.html

requirements.txt

@@ -0,0 +1,4 @@
+setuptools
+psutil
+click
+distro

scripts/auto-cpufreq-dinit

@@ -1,3 +0,0 @@
-type = scripted
-command = /usr/local/bin/auto-cpufreq --daemon
-run-as = root

scripts/auto-cpufreq-gtk.desktop

@@ -1,8 +0,0 @@
-[Desktop Entry]
-Name=auto-cpufreq
-Exec=auto-cpufreq-gtk
-Type=Application
-Terminal=false
-Icon=auto-cpufreq
-StartupWMClass=app.py
-Categories=System;

scripts/auto-cpufreq-install.sh

@@ -1,96 +1,85 @@
-#!/usr/bin/env bash
+#!/bin/bash
 #
 # auto-cpufreq daemon install script
 # reference: https://github.com/AdnanHodzic/auto-cpufreq
 # Thanks to https://github.com/errornonamer for openrc fix
+echo -e "\n------------------ Running auto-cpufreq daemon install script ------------------"
 
-MID="$((`tput cols` / 2))"
+if [[ $EUID != 0 ]];
-
+then
-echo
+	echo -e "\nERROR\nMust be run as root (i.e: 'sudo $0')\n"
-printf "%0.s─" $(seq $(( (MID-(${#1}/2)-2) / 2 )))
-printf " Running auto-cpufreq daemon install script "
-printf "%0.s─" $(seq $(( (MID-(${#1}/2)-2) / 2 )))
-echo; echo
-
-# root check
-if ((EUID != 0)); then
-  echo; echo "Must be run as root (i.e: 'sudo $0')."; echo
 	exit 1
 fi
 
-# First argument is the init name, second argument is the start command, third argument is the enable command
+# First argument is the "sv" path, second argument is the "service" path this
-function auto_cpufreq_install {
+# only exist because the path between distros may vary
-    echo -e "\n* Starting auto-cpufreq daemon ($1) service"
-    $2
-    echo -e "\n* Enabling auto-cpufreq daemon ($1) at boot"
-    $3
-}
-
-case "$(ps h -o comm 1)" in
-  dinit) 
-    echo -e "\n* Deploying auto-cpufreq (dinit) unit file"
-    cp /usr/local/share/auto-cpufreq/scripts/auto-cpufreq-dinit /etc/dinit.d/auto-cpufreq
-
-    auto_cpufreq_install "dinit" "dinitctl start auto-cpufreq" "dinitctl enable auto-cpufreq"
-  ;;
-  init) 
-    echo -e "\n* Deploying auto-cpufreq openrc unit file"
-    cp /usr/local/share/auto-cpufreq/scripts/auto-cpufreq-openrc /etc/init.d/auto-cpufreq
-    chmod +x /etc/init.d/auto-cpufreq
-
-    auto_cpufreq_install "openrc" "rc-service auto-cpufreq start" "rc-update add auto-cpufreq"
-  ;;
-  runit)
-    # First argument is the "sv" path, second argument is the "service" path
 runit_ln() {
-      echo -e "\n* Deploying auto-cpufreq (runit) unit file"
+	echo -e "\n* Deploy auto-cpufreq runit unit file"
 	mkdir "$1"/sv/auto-cpufreq
 	cp /usr/local/share/auto-cpufreq/scripts/auto-cpufreq-runit "$1"/sv/auto-cpufreq/run
 	chmod +x "$1"/sv/auto-cpufreq/run
 
 	echo -e "\n* Creating symbolic link ($2/service/auto-cpufreq -> $1/sv/auto-cpufreq)"
 	ln -s "$1"/sv/auto-cpufreq "$2"/service
+}
 
-      auto_cpufreq_install "runit"
+# sv commands
-
+sv_cmd() {
+	echo -e "\n* Stopping auto-cpufreq daemon (runit) service"
+	sv stop auto-cpufreq
+	echo -e "\n* Starting auto-cpufreq daemon (runit) service"
 	sv start auto-cpufreq
 	sv up auto-cpufreq
 }
 
+# Installation for runit, we still look for the distro because of the path may
+# vary.
+if [ "$(ps h -o comm 1)" = "runit" ];then
 	if [ -f /etc/os-release ];then
 		eval "$(cat /etc/os-release)"
 		case $ID in
-        void) runit_ln /etc /var;;
+			void)
-        artix) runit_ln /etc/runit /run/runit;;
+				runit_ln /etc /var
+				sv_cmd
+			;;
+			artix)
+			# Note: Artix supports other inits than runnit
+				runit_ln /etc/runit /run/runit
+				sv_cmd
+			;;
 			*)
 				echo -e "\n* Runit init detected but your distro is not supported\n"
 				echo -e "\n* Please open an issue on https://github.com/AdnanHodzic/auto-cpufreq\n"
 		esac
 	fi
-  ;;
+# Install script for systemd
-  systemd)
+elif [ "$(ps h -o comm 1)" = "systemd" ];then
-    echo -e "Deploying auto-cpufreq systemd unit file"
+    echo -e "\n* Deploy auto-cpufreq systemd unit file"
     cp /usr/local/share/auto-cpufreq/scripts/auto-cpufreq.service /etc/systemd/system/auto-cpufreq.service
 
     echo -e "\n* Reloading systemd manager configuration"
     systemctl daemon-reload
 
-    auto_cpufreq_install "systemd" "systemctl start auto-cpufreq" "systemctl enable auto-cpufreq"
+    echo -e "\n* Stopping auto-cpufreq daemon (systemd) service"
-  ;;
+    systemctl stop auto-cpufreq
-  s6-svscan)
-	  echo -e "\n* Deploying auto-cpufreq (s6) unit file"
-    cp -r /usr/local/share/auto-cpufreq/scripts/auto-cpufreq-s6 /etc/s6/sv/auto-cpufreq
 
-    echo -e "\n* Add auto-cpufreq service (s6) to default bundle"
+    echo -e "\n* Starting auto-cpufreq daemon (systemd) service"
-    s6-service add default auto-cpufreq
+    systemctl start auto-cpufreq
 
-    auto_cpufreq_install "s6" "s6-rc -u change auto-cpufreq default"
+    echo -e "\n* Enabling auto-cpufreq daemon (systemd) service at boot"
+    systemctl enable auto-cpufreq
+# Install script for openrc
+elif [ "$(ps h -o comm 1)" = "init" ];then
+	echo -e "\n* Deploying auto-cpufreq openrc unit file"
+	cp /usr/local/share/auto-cpufreq/scripts/auto-cpufreq-openrc /etc/init.d/auto-cpufreq
+	chmod +x /etc/init.d/auto-cpufreq
 
-    echo -e "\n* Update daemon service bundle (s6)"
+	echo -e "Starting auto-cpufreq daemon (openrc) service"
-    s6-db-reload
+	rc-service auto-cpufreq start
-  ;;
+
-  *)
+	echo -e "\n* Enabling auto-cpufreq daemon (openrc) service at boot"
+	rc-update add auto-cpufreq
+else
   echo -e "\n* Unsupported init system detected, could not install the daemon\n"
   echo -e "\n* Please open an issue on https://github.com/AdnanHodzic/auto-cpufreq\n"
-  ;;
+fi
-esac

scripts/auto-cpufreq-remove.sh

@@ -4,68 +4,64 @@
 # reference: https://github.com/AdnanHodzic/auto-cpufreq
 # Thanks to https://github.com/errornonamer for openrc fix
 
-MID="$((`tput cols` / 2))"
+echo -e "\n------------------ Running auto-cpufreq daemon removal script ------------------"
 
-echo
+if [[ $EUID != 0 ]]; then
-printf "%0.s─" $(seq $(( (MID-(${#1}/2)-2) / 2 )))
+	echo -e "\nERROR\nMust be run as root (i.e: 'sudo $0')\n"
-printf " Running auto-cpufreq daemon removal script "
-printf "%0.s─" $(seq $(( (MID-(${#1}/2)-2) / 2 )))
-echo; echo
-
-# root check
-if ((EUID != 0)); then
-  echo; echo "Must be run as root (i.e: 'sudo $0')."; echo
 	exit 1
 fi
 
-# First argument is the init name, second argument is the stop command, third argument is the disable command and the fourth is the "service" path
-function auto_cpufreq_remove {
-    echo -e "\n* Stopping auto-cpufreq daemon ($1) service"
-    $2
-    echo -e "\n* Disabling auto-cpufreq daemon ($1) at boot"
-    $3
-    echo -e "\n* Removing auto-cpufreq daemon ($1) unit file"
-    rm $4
-}
-
-case "$(ps h -o comm 1)" in
-  dinit) auto_cpufreq_remove "dinit" "dinitctl stop auto-cpufreq" "dinitctl disable auto-cpufreq" "/etc/dinit.d/auto-cpufreq";;
-  init) auto_cpufreq_remove "openrc" "rc-service auto-cpufreq stop" "rc-update del auto-cpufreq" "/etc/init.d/auto-cpufreq";;
-  runit)
 # First argument is the "sv" path, second argument is the "service" path
 rm_sv() {
-      auto_cpufreq_remove "runit" "sv stop auto-cpufreq" "" "-rf $1/sv/auto-cpufreq $2/service/auto-cpufreq"
+    echo -e "\n* Stopping auto-cpufreq daemon (runit) service"
+    sv stop auto-cpufreq
+
+    echo -e "\n* Removing auto-cpufreq daemon (runit) unit files"
+    rm -rf "$1"/sv/auto-cpufreq
+    rm -rf "$2"/service/auto-cpufreq
 }
 
+# Remove service for runit
+if [ "$(ps h -o comm 1)" = "runit" ];then
 	if [ -f /etc/os-release ];then
-      . /etc/os-release
+		eval "$(cat /etc/os-release)"
 		case $ID in
-        void) rm_sv /etc /var;;
+			void)
-        artix) rm_sv /etc/runit /run/runit;;
+				rm_sv /etc /var ;;
+			artix)
+				rm_sv /etc/runit /run/runit ;;
 			*)
 				echo -e "\n* Runit init detected but your distro is not supported\n"
 				echo -e "\n* Please open an issue on https://github.com/AdnanHodzic/auto-cpufreq\n"
-        ;;
+
 		esac
 	fi
-  ;;
+# Remove service for systemd
-  systemd)
+elif [ "$(ps h -o comm 1)" = "systemd" ];then
-    auto_cpufreq_remove "systemd" "systemctl stop auto-cpufreq" "systemctl disable auto-cpufreq" "/etc/systemd/system/auto-cpufreq.service"
+    echo -e "\n* Stopping auto-cpufreq daemon (systemd) service"
+    systemctl stop auto-cpufreq
+
+    echo -e "\n* Disabling auto-cpufreq daemon (systemd) at boot"
+    systemctl disable auto-cpufreq
+
+    echo -e "\n* Removing auto-cpufreq daemon (systemd) unit file"
+    rm /etc/systemd/system/auto-cpufreq.service
 
     echo -e "\n* Reloading systemd manager configuration"
     systemctl daemon-reload
 
-    echo "reset failed"
+    echo -e "reset failed"
     systemctl reset-failed
-  ;;
+elif [ "$(ps h -o comm 1)" = "init" ];then
-  s6-svscan)
+	echo -e "\n* Stopping auto-cpufreq daemon (openrc) service"
-    auto_cpufreq_remove "s6" "" "s6-service delete default auto-cpufreq" "-rf /etc/s6/sv/auto-cpufreq"
+	rc-service auto-cpufreq stop
 
-    echo -e "\n* Update daemon service bundle (s6)"
+	echo -e "\n* Disabling auto-cpufreq daemon (openrc) at boot"
-    s6-db-reload
+	rc-update del auto-cpufreq
-  ;;
+
-  *)
+	echo -e "\n* Removing auto-cpufreq daemon (openrc) unit file"
-    echo -e "\n* Unsupported init system detected, could not remove the daemon"
+	rm /etc/init.d/auto-cpufreq
+else
+  echo -e "\n* Unsupported init system detected, could not remove the daemon\n"
   echo -e "\n* Please open an issue on https://github.com/AdnanHodzic/auto-cpufreq\n"
-  ;;
+fi
-esac

scripts/auto-cpufreq-runit

@@ -1,3 +1,2 @@
-#!/bin/bash
+#!/bin/sh
-export PATH="$PATH:/usr/local/bin"
 exec /usr/local/bin/auto-cpufreq --daemon

scripts/auto-cpufreq-s6/run

@@ -1,4 +0,0 @@
-#!/bin/sh
-
-exec /usr/local/bin/auto-cpufreq --daemon
-

scripts/auto-cpufreq-s6/type

@@ -1 +0,0 @@
-longrun

scripts/auto-cpufreq-venv-wrapper

@@ -1,17 +1,34 @@
-#!/bin/bash
+#!/bin/sh
 # Wrapper script around auto-cpufreq using the python virtual environment
 
 set -eu
 
+# get script name
+PROGNAME=$(basename "${0}")
+
 # bailout function
-err_exit() {
+err_exit()
-  echo "$(basename $0): ${1:-wrong invocation. try --help for help.}" 1>&2
+{
+    echo "${PROGNAME}: ${1:-wrong invocation. try --help for help.}" 1>&2
     exit 1
 }
 
-# load python virtual environment
+# invocation handling
-opt_path=/opt/auto-cpufreq
+#
-venv_bin_dir=$opt_path/venv/bin
+param=""
-. "$venv_bin_dir/activate"
+if [ "${#}" -ne 1 ];
+then
+    err_exit
+else
+    param="${1}"
+fi
 
-PYTHONPATH=$opt_path $venv_bin_dir/python $venv_bin_dir/auto-cpufreq "$@"
+# load python virtual environment
+venv_dir=/opt/auto-cpufreq/venv
+. "${venv_dir}/bin/activate"
+
+# run python code with venv loaded
+PYTHONPATH=/opt/auto-cpufreq \
+            /opt/auto-cpufreq/venv/bin/python \
+            /opt/auto-cpufreq/venv/bin/auto-cpufreq \
+            "${param}"

scripts/auto-cpufreq.service

@@ -1,5 +1,6 @@
 [Unit]
 Description=auto-cpufreq - Automatic CPU speed & power optimizer for Linux
+After=network.target network-online.target
 
 [Service]
 Type=simple

scripts/cpufreqctl.sh

@@ -3,18 +3,18 @@
 VERSION='20'
 cpucount=`cat /proc/cpuinfo|grep processor|wc -l`
 FLROOT=/sys/devices/system/cpu
-FWROOT=/sys/firmware
 DRIVER=auto
 VERBOSE=0
 
 ## parse special options
-for i in "$@"; do
+for i in "$@"
+do
 case $i in
   -v|--verbose)
   VERBOSE=1
   shift
   ;;
-    -s=*|--set=*)
+  --set=*)
   VALUE="${i#*=}"
   shift
   ;;
@@ -22,7 +22,7 @@ for i in "$@"; do
   CORE="${i#*=}"
   shift
   ;;
-    -a|--available)
+  --available)
   AVAILABLE=1
   shift
   ;;
@@ -30,39 +30,41 @@ for i in "$@"; do
   OPTION=$i
   shift
   ;;
-    *) exit 1;;
+  *) # unknown
+  ;;
 esac
 done
 
 function help () {
   echo "Package version: "$VERSION
-  echo "Usage: cpufreqctl [OPTION[=VALUE]...]"
+  echo "Usage:"
-  echo
+  echo "  cpufreqctl [OPTION[=VALUE]...]"
-  echo "  -h, --help                  Show help options"
+  echo ""
+  echo "  --help                 Show help options"
   echo "  --version              Package version"
-  echo "  -v, --verbose               Verbose output"
+  echo "  --verbose, -v          Verbose output"
-  echo
+  echo ""
-  echo "  -s, --set       =VALUE      Set VALUE for selected option"
+  echo "  --set=VALUE            Set VALUE for selected option"
-  echo "  -c, --core      =NUMBER     Apply selected option just for the core NUMBER (0 ~ N - 1)"
+  echo "  --core=NUMBER          Apply selected option just for the core NUMBER (0 ~ N - 1)"
-  echo "  -a, --available             Get available values instand of default: current"
+  echo "  --available            Get available values instand of default: current"
-  echo
+  echo ""
-  echo "  -d, --driver                Current processor driver"
+  echo "  --driver               Current processor driver"
-  echo "  -g, --governor              Scaling governor's options"
+  echo "  --governor             Scaling governor's options"
-  echo "  -e, --epp                   Governor's energy_performance_preference options"
+  echo "  --epp                  Governor's energy_performance_preference options"
-  echo "  -f, --frequency             Frequency options"
+  echo "  --frequency            Frequency options"
   echo "  --on                   Turn on --core=NUMBER"
   echo "  --off                  Turn off --core=NUMBER"
   echo "  --frequency-min        Minimal frequency options"
   echo "  --frequency-max        Maximum frequency options"
   echo "  --frequency-min-limit  Get minimal frequency limit"
   echo "  --frequency-max-limit  Get maximum frequency limit"
-  echo "  -b, --boost                 Current cpu boost value"
+  echo "  --boost                Current cpu boost value"
-  echo
+  echo ""
   echo "intel_pstate options"
   echo "  --no-turbo      Current no_turbo value"
   echo "  --min-perf      Current min_perf_pct options"
   echo "  --max-perf      Current max_perf_pct options"
-  echo
+  echo ""
   echo "Events options"
   echo "  --throttle      Get thermal throttle counter"
   echo "  --throttle-event Get kernel thermal throttle events counter"
@@ -71,34 +73,33 @@ function help () {
 
 function info () {
   echo "CPU driver: "`driver`
-  echo "Governors: "`cat $FLROOT/cpu0/cpufreq/scaling_available_governors`
+  echo "Governors: "`cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors`
-  echo "Frequencies: "`cat $FLROOT/cpu0/cpufreq/scaling_available_frequencies`
+  echo "Frequencies: "`cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies`
-  echo
+  echo ""
   echo "Usage:"
   echo "## list scaling governors:"
   echo "cpufreqctl --governor"
-  echo
+  echo ""
   echo "## Set all active cpu cores to the 'performance' scaling governor:"
   echo "cpufreqctl --governor --set=performance"
-  echo
+  echo ""
   echo "## Set 'performance' scaling governor for the selected core:"
   echo "cpufreqctl --governor --set=performance --core=0"
-  echo
+  echo ""
   echo "Use --help argument to see available options"
 }
 
 verbose () {
-  if [ $VERBOSE = 1 ]; then echo $1; fi
+  if [ $VERBOSE = 1 ]
+  then
+    echo $1
+  fi
 }
 
 function driver () {
   cat $FLROOT/cpu0/cpufreq/scaling_driver
 }
 
-function write_value () {
-  if [ -w $FLNM ]; then echo $VALUE > $FLNM; fi
-}
-
 function set_driver () {
   DRIVER=`driver`
   case $DRIVER in
@@ -112,339 +113,376 @@ function get_governor () {
   then
     i=0
     ag=''
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
-      if [ $i = 0 ]; then ag=`cat $FLROOT/cpu0/cpufreq/scaling_governor`
+    do
-      else ag=$ag' '`cat $FLROOT/cpu$i/cpufreq/scaling_governor`
+      if [ $i = 0 ]
+      then
+        ag=`cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor`
+      else
+        ag=$ag' '`cat /sys/devices/system/cpu/cpu$i/cpufreq/scaling_governor`
       fi
       i=`expr $i + 1`
     done
     echo $ag
-  else cat $FLROOT/cpu$CORE/cpufreq/scaling_governor
+  else
+    cat /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_governor
   fi
 }
 
 function set_governor () {
-  if [ -z $CORE ]; then
+  if [ -z $CORE ]
+  then
     i=0
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
+    do
       FLNM="$FLROOT/cpu"$i"/cpufreq/scaling_governor"
-      write_value
+      echo $VALUE > $FLNM
       i=`expr $i + 1`
     done
-  else echo $VALUE > $FLROOT/cpu$CORE/cpufreq/scaling_governor
+  else
+    echo $VALUE > /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_governor
   fi
 }
 
 function get_frequency () {
-  if [ -z $CORE ]; then
+  if [ -z $CORE ]
+  then
     i=0
     V=0
-    M=$(cat "$FLROOT/cpu0/cpufreq/scaling_cur_freq")
+    M=$(cat "/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq")
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
-      V=$(cat "$FLROOT/cpu"$i"/cpufreq/scaling_cur_freq")
+    do
-      if [[ $V > $M ]]; then M=$V; fi
+      V=$(cat "/sys/devices/system/cpu/cpu"$i"/cpufreq/scaling_cur_freq")
+      if [[ $V > $M ]]
+      then
+        M=$V
+      fi
       i=`expr $i + 1`
     done
     echo "$M"
-  else cat $FLROOT/cpu$CORE/cpufreq/scaling_cur_freq
+  else
+    cat /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_cur_freq
   fi
 }
 
 function set_frequency () {
   set_driver
-  if [ $DRIVER = 'pstate' ]; then
+  if [ $DRIVER = 'pstate']
-    echo "Unavailable function for intel_pstate"
+  then
+    echo "Unavaible function for intel_pstate"
     return
   fi
-  if [ -z $CORE ]; then
+  if [ -z $CORE ]
+  then
     i=0
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
+    do
       FLNM="$FLROOT/cpu"$i"/cpufreq/scaling_setspeed"
-      write_value
+      echo $VALUE > $FLNM
       i=`expr $i + 1`
     done
-  else echo $VALUE > $FLROOT/cpu$CORE/cpufreq/scaling_setspeed
+  else
+    echo $VALUE > /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_setspeed
   fi
 }
 
 function get_frequency_min () {
-  if [ -z $CORE ]; then CORE=0; fi
+  if [ -z $CORE ]
-  cat $FLROOT/cpu$CORE/cpufreq/scaling_min_freq
+  then
+    CORE=0
+  fi
+  cat /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_min_freq
 }
 
 function set_frequency_min () {
-  if [ -z $CORE ]; then
+  if [ -z $CORE ]
+  then
     i=0
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
+    do
       FLNM="$FLROOT/cpu"$i"/cpufreq/scaling_min_freq"
-      write_value
+      echo $VALUE > $FLNM
       i=`expr $i + 1`
     done
-  else echo $VALUE > $FLROOT/cpu$CORE/cpufreq/scaling_min_freq
+  else
+    echo $VALUE > /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_min_freq
   fi
 }
 
 function get_frequency_max () {
-  if [ -z $CORE ]; then CORE=0; fi
+  if [ -z $CORE ]
-  cat $FLROOT/cpu$CORE/cpufreq/scaling_max_freq
+  then
+    CORE=0
+  fi
+  cat /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_max_freq
 }
 
 function set_frequency_max () {
-  if [ -z $CORE ]; then
+  if [ -z $CORE ]
+  then
     i=0
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
+    do
       FLNM="$FLROOT/cpu"$i"/cpufreq/scaling_max_freq"
-      write_value
+      echo $VALUE > $FLNM
       i=`expr $i + 1`
     done
-  else echo $VALUE > $FLROOT/cpu$CORE/cpufreq/scaling_max_freq
+  else
+    echo $VALUE > /sys/devices/system/cpu/cpu$CORE/cpufreq/scaling_max_freq
   fi
 }
 
 function get_frequency_min_limit () {
-  if [ -z $CORE ]; then CORE=0; fi
+  if [ -z $CORE ]
-  cat $FLROOT/cpu$CORE/cpufreq/cpuinfo_min_freq
+  then
+    CORE=0
+  fi
+  cat /sys/devices/system/cpu/cpu$CORE/cpufreq/cpuinfo_min_freq
 }
 
 function get_frequency_max_limit () {
-  if [ -z $CORE ]; then CORE=0; fi
+  if [ -z $CORE ]
-  cat $FLROOT/cpu$CORE/cpufreq/cpuinfo_max_freq
+  then
+    CORE=0
+  fi
+  cat /sys/devices/system/cpu/cpu$CORE/cpufreq/cpuinfo_max_freq
 }
 
 function get_energy_performance_preference () {
-  if [ -z $CORE ]; then
+  if [ -z $CORE ]
+  then
     i=0
     ag=''
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
-      if [ $i = 0 ]; then
+    do
-        ag=`cat $FLROOT/cpu0/cpufreq/energy_performance_preference`
+      if [ $i = 0 ]
+      then
+        ag=`cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_preference`
       else
-        ag=$ag' '`cat $FLROOT/cpu$i/cpufreq/energy_performance_preference`
+        ag=$ag' '`cat /sys/devices/system/cpu/cpu$i/cpufreq/energy_performance_preference`
       fi
       i=`expr $i + 1`
     done
     echo $ag
-  else cat $FLROOT/cpu$CORE/cpufreq/energy_performance_preference
+  else
+    cat /sys/devices/system/cpu/cpu$CORE/cpufreq/energy_performance_preference
   fi
 }
 
 function set_energy_performance_preference () {
-  if [ -z $CORE ]; then
+  if [ -z $CORE ]
+  then
     i=0
-    while [ $i -ne $cpucount ]; do
+    while [ $i -ne $cpucount ]
+    do
       FLNM="$FLROOT/cpu"$i"/cpufreq/energy_performance_preference"
-      write_value
+      echo $VALUE > $FLNM
       i=`expr $i + 1`
     done
-  else echo $VALUE > $FLROOT/cpu$CORE/cpufreq/energy_performance_preference
-  fi
-}
-
-
-function get_energy_performance_bias () {
-  if [ -z $CORE ]; then
-    i=0
-    ag=''
-    while [ $i -ne $cpucount ]; do
-      if [ $i = 0 ]; then
-        ag=`cat $FLROOT/cpu0/power/energy_perf_bias`
   else
-        ag=$ag' '`cat $FLROOT/cpu$i/power/energy_perf_bias`
+    echo $VALUE > /sys/devices/system/cpu/cpu$CORE/cpufreq/energy_performance_preference
-      fi
-      i=`expr $i + 1`
-    done
-    echo $ag
-  else cat $FLROOT/cpu$CORE/power/energy_perf_bias
   fi
 }
 
-function set_energy_performance_bias () {
+if [ -z $OPTION ] # No options
-  if [ `driver` != 'intel_pstate' ]; then
+then
-    verbose "EPB is not supported by a driver other than intel_pstate"
+  info
-    return
+  exit
 fi
-  local EPB_VALUE=6 # default value
+if [ $OPTION = "--help" ]
-  if [[ "$VALUE" =~ ^[0-9]+$ && $VALUE -ge 0 && $VALUE -le 15 ]]; then
+then
-    EPB_VALUE=$VALUE
+  help
-  else
+  exit
-    case $VALUE in
-      performance) EPB_VALUE=0;;
-      balance_performance) EPB_VALUE=4;;
-      default) EPB_VALUE=6;;
-      balance_power) EPB_VALUE=8;;
-      power) EPB_VALUE=15;;
-      *)
-        verbose "Invalid value provided for EPB"
-        verbose "Acceptable values: performance|balance-power|default|balance-power|power or a number in the range [0-15]"
-        return
-      ;;
-    esac
 fi
-
+if [ $OPTION = "--version" ]
-  if [ -z $CORE ]; then
+then
-    i=0
+  echo $VERSION
-    while [ $i -ne $cpucount ]; do
+  exit
-      FLNM="$FLROOT/cpu"$i"/power/energy_perf_bias"
-      if [ -w $FLNM ]; then echo $EPB_VALUE > $FLNM; fi
-      i=`expr $i + 1`
-    done
-  else echo $EPB_VALUE > $FLROOT/cpu$CORE/power/energy_perf_bias
 fi
-}
+if [ $OPTION = "--driver" ]
-
+then
-case $OPTION in
+	driver
-  -h|--help) help;;
+	exit
-  --version) echo $VERSION;;
+fi
-  -d|--driver) driver;;
+if [ $OPTION = "--governor" ]
-  -g|--governor)
+then
-    if [ ! -z $AVAILABLE ]; then cat $FLROOT/cpu0/cpufreq/scaling_available_governors
+  if [ ! -z $AVAILABLE ]
-    elif [ -z $VALUE ]; then
+  then
+    cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors
+    exit
+  fi
+  if [ -z $VALUE ]
+  then
     verbose "Getting CPU"$CORE" governors"
     get_governor
   else
     verbose "Setting CPU"$CORE" governors to "$VALUE
     set_governor
   fi
-  ;;
+  exit
-  -e|--epp)
+fi
-    if [ ! -z $AVAILABLE ]; then cat $FLROOT/cpu0/cpufreq/energy_performance_available_preferences
+if [ $OPTION = "--epp" ]
-    elif [ -z $VALUE ]; then
+then
+  if [ ! -z $AVAILABLE ]
+  then
+    cat /sys/devices/system/cpu/cpu0/cpufreq/energy_performance_available_preferences
+    exit
+  fi
+  if [ -z $VALUE ]
+  then
     verbose "Getting CPU"$CORE" EPPs"
     get_energy_performance_preference
   else
     verbose "Setting CPU"$CORE" EPPs to "$VALUE
     set_energy_performance_preference
   fi
-  ;;
+  exit
-  --epb)
-    if [ ! -z $AVAILABLE ]; then cat $FLROOT/cpu0/power/energy_perf_bias
-    elif [ -z $VALUE ]; then 
-      verbose "Getting CPU"$CORE" EPBs"
-      get_energy_performance_bias
-    else
-      verbose "Setting CPU"$CORE" EPBs to "$VALUE
-      set_energy_performance_bias
 fi
-  ;;
+if [ $OPTION = "--frequency" ]
-  -p|--pp)
+then
-    if [ ! -z $AVAILABLE ]; then cat $FWROOT/acpi/platform_profile_choices
+  if [ ! -z $AVAILABLE ]
-    elif [ -z $VALUE ]; then
+  then
-      verbose "Getting Platform Profile"
+    cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_available_frequencies
-      cat $FWROOT/acpi/platform_profile
+    exit
-    else
-      verbose "Getting Platform Profile to "$VALUE
-      echo $VALUE > $FWROOT/acpi/platform_profile
   fi
-  ;;
+  if [ -z $VALUE ]
-  -f|--frequency)
+  then
-    if [ ! -z $AVAILABLE ]; then cat $FLROOT/cpu0/cpufreq/scaling_available_frequencies
-    elif [ -z $VALUE ]; then
     verbose "Getting CPU"$CORE" frequency"
     get_frequency
   else
     verbose "Setting CPU"$CORE" frequency to "$VALUE
     set_frequency
   fi
-  ;;
+  exit
-  --no-turbo)
+fi
-    if [ -z $VALUE ]; then
+if [ $OPTION = "--no-turbo" ]
+then
+  if [ -z $VALUE ]
+  then
     verbose "Getting no_turbo value"
-      cat $FLROOT/intel_pstate/no_turbo
+    cat /sys/devices/system/cpu/intel_pstate/no_turbo
   else
     verbose "Setting no_turbo value "$VALUE
-      echo $VALUE > $FLROOT/intel_pstate/no_turbo
+    echo $VALUE > /sys/devices/system/cpu/intel_pstate/no_turbo
   fi
-  ;;
+  exit
-  -b|--boost)
+fi
-    if [ -z $VALUE ]; then
+if [ $OPTION = "--boost" ]
+then
+  if [ -z $VALUE ]
+  then
     verbose "Getting boost value"
-      cat $FLROOT/cpufreq/boost
+    cat /sys/devices/system/cpu/cpufreq/boost
   else
     verbose "Setting boost value "$VALUE
-      echo $VALUE > $FLROOT/cpufreq/boost
+    echo $VALUE > /sys/devices/system/cpu/cpufreq/boost
   fi
-  ;;
+  exit
-  --frequency-min)
+fi
-    if [ -z $VALUE ]; then
+if [ $OPTION = "--frequency-min" ]
+then
+  if [ -z $VALUE ]
+  then
     verbose "Getting CPU"$CORE" minimal frequency"
     get_frequency_min
   else
     verbose "Setting CPU"$CORE" minimal frequency to "$VALUE
     set_frequency_min
   fi
-  ;;
+  exit
-  --frequency-max)
+fi
-    if [ -z $VALUE ]; then
+if [ $OPTION = "--frequency-max" ]
+then
+  if [ -z $VALUE ]
+  then
     verbose "Getting CPU"$CORE" maximal frequency"
     get_frequency_max
   else
     verbose "Setting CPU"$CORE" maximal frequency to "$VALUE
     set_frequency_max
   fi
-  ;;
+  exit
-  --frequency-min-limit)
+fi
+if [ $OPTION = "--frequency-min-limit" ]
+then
     verbose "Getting CPU"$CORE" minimal frequency limit"
     get_frequency_min_limit
-  ;;
+fi
-  --frequency-max-limit)
+if [ $OPTION = "--frequency-max-limit" ]
+then
     verbose "Getting CPU"$CORE" maximum frequency limit"
     get_frequency_max_limit
-  ;;
+fi
-  --min-perf)
+if [ $OPTION = "--min-perf" ]
-    if [ -z $VALUE ]; then
+then
+  if [ -z $VALUE ]
+  then
     verbose "Getting min_perf_pct value"
-      cat $FLROOT/intel_pstate/min_perf_pct
+    cat /sys/devices/system/cpu/intel_pstate/min_perf_pct
   else
     verbose "Setting min_perf_pct value "$VALUE
-      echo $VALUE > $FLROOT/intel_pstate/min_perf_pct
+    echo $VALUE > /sys/devices/system/cpu/intel_pstate/min_perf_pct
   fi
-  ;;
+  exit
-  --max-perf)
+fi
-    if [ -z $VALUE ]; then
+if [ $OPTION = "--max-perf" ]
+then
+  if [ -z $VALUE ]
+  then
     verbose "Getting max_perf_pct value"
-      cat $FLROOT/intel_pstate/max_perf_pct
+    cat /sys/devices/system/cpu/intel_pstate/max_perf_pct
   else
     verbose "Setting max_perf_pct value "$VALUE
-      echo $VALUE > $FLROOT/intel_pstate/max_perf_pct
+    echo $VALUE > /sys/devices/system/cpu/intel_pstate/max_perf_pct
   fi
-  ;;
+  exit
-  --on)
+fi
-    if [ -z $CORE ]; then verbose "Should be specify --core=NUMBER"
+if [ $OPTION = "--on" ]
+then
+  if [ -z $CORE ]
+  then
+    verbose "Should be specify --core=NUMBER"
   else
     verbose "Power on CPU Core"$CORE
     echo "1" > $FLROOT/cpu"$CORE"/online
   fi
-  ;;
+  exit
-  --off)
+fi
-    if [ -z $CORE ]; then verbose "Should be specify --core=NUMBER"
+if [ $OPTION = "--off" ]
+then
+  if [ -z $CORE ]
+  then
+    verbose "Should be specify --core=NUMBER"
   else
-      verbose "Power off CPU Core$CORE"
+    verbose "Power off CPU Core"$CORE
     echo "0" > $FLROOT/cpu"$CORE"/online
   fi
-  ;;
+  exit
-  --throttle)
+fi
+
+if [ $OPTION = "--throttle" ]
+then
   i=1
   V=0
-    M=$(cat "$FLROOT/cpu0/thermal_throttle/core_throttle_count")
+  M=$(cat "/sys/devices/system/cpu/cpu0/thermal_throttle/core_throttle_count")
-    while [ $i -ne $cpucount ]; do
+  while [ $i -ne $cpucount ]
-      V=$(cat "$FLROOT/cpu$i/thermal_throttle/core_throttle_count")
+  do
+    V=$(cat "/sys/devices/system/cpu/cpu"$i"/thermal_throttle/core_throttle_count")
     M=`expr $M + $V`
     i=`expr $i + 1`
   done
   echo "$M"
-  ;;
+  exit
-  --throttle-events)
+fi
+if [ $OPTION = "--throttle-events" ]
+then
   M=$(journalctl --dmesg --boot --since=yesterday | grep "cpu clock throttled" | wc -l)
   echo "$M"
-  ;;
+  exit
-  --irqbalance)
+fi
+if [ $OPTION = "--irqbalance" ]
+then
   M=$(ps -A |grep irqbalance)
   echo "$M"
-  ;;
+  exit
-  *)
+fi
-    info
-    exit 1
-  ;;
-esac
-
-exit 0

scripts/org.auto-cpufreq.pkexec.policy

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE policyconfig PUBLIC
- "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
- "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd">
-<policyconfig>
-    <action id="org.auto-cpufreq.pkexec">
-    <description>Run auto-cpufreq command</description>
-    <message>Authentication is required to run auto-cpufreq</message>
-    <icon_name>auto-cpufreq</icon_name>
-    <defaults>
-        <allow_any>auth_admin</allow_any>
-        <allow_inactive>auth_admin</allow_inactive>
-        <allow_active>auth_admin</allow_active>
-    </defaults>
-    <annotate key="org.freedesktop.policykit.exec.path">/opt/auto-cpufreq/venv/bin/auto-cpufreq</annotate>
-    <!-- <annotate key="org.freedesktop.policykit.exec.argv1">/opt/auto-cpufreq/venv/bin/auto-cpufreq</annotate>  -->
-    <!-- <annotate key="org.freedesktop.policykit.exec.allow_gui">true</annotate> -->
-    </action>
-</policyconfig>

scripts/snapdaemon.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/bash
 #
 # workaround for running Daemon without polluting syslog (#53, #82)
 $SNAP/bin/auto-cpufreq --daemon 2>&1 >> $SNAP_DATA/auto-cpufreq.stats

scripts/start_app

@@ -1,18 +0,0 @@
-#!/usr/bin/sh
-
-# load python virtual environment
-venv_dir=/opt/auto-cpufreq/venv
-. "$venv_dir/bin/activate"
-python_command="$venv_dir/bin/auto-cpufreq-gtk"
-
-# if [ "$XDG_SESSION_TYPE" = "wayland" ] ; then
-#     # necessary for running on wayland
-#     xhost +SI:localuser:root
-#     pkexec $python_command
-#     xhost -SI:localuser:root
-#     xhost
-# else
-#     pkexec $python_command
-# fi
-
-$python_command

scripts/style.css

@@ -1,8 +0,0 @@
-label {
-    /*font-family: Noto Sans;*/
-    font-size: 15px;
-}
-
-#bold { font-weight: bold; }
-
-#small { font-size: 12px; }

setup.py

@@ -0,0 +1,44 @@
+import os
+
+from setuptools import setup
+
+with open("README.md") as readme_file:
+    readme = readme_file.read()
+
+this = os.path.dirname(os.path.realpath(__file__))
+
+
+def read(name):
+    with open(os.path.join(this, name)) as f:
+        return f.read()
+
+# Used for the tar.gz/snap releases
+VERSION = "1.9.1"
+
+setup(
+    name="auto-cpufreq",
+    setuptools_git_versioning={
+        "starting_version": VERSION,
+        "template": "{tag}+{sha}",
+        "dev_template": "{tag}+{sha}",
+        "dirty_template": "{tag}+{sha}.post{ccount}.dirty"
+    },
+    setup_requires=["setuptools-git-versioning"],
+    description="Automatic CPU speed & power optimizer for Linux",
+    long_description=readme,
+    author="Adnan Hodzic",
+    author_email="adnan@hodzic.org",
+    url="https://github.com/AdnanHodzic/auto-cpufreq",
+    packages=["auto_cpufreq"],
+    install_requires=read("requirements.txt"),
+    include_package_data=True,
+    zip_safe=True,
+    license="GPLv3",
+    keywords="linux cpu speed power frequency turbo optimzier auto cpufreq",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Intended Audience :: Developers",
+        "Operating System :: POSIX :: Linux" "Environment :: Console" "Natural Language :: English",
+    ],
+    scripts=["bin/auto-cpufreq"],
+)

snap/gui/auto-cpufreq_auto-cpufreq.desktop

@@ -1,10 +0,0 @@
-[Desktop Entry]
-Type=Application
-Encoding=UTF-8
-Name=auto-cpufreq
-Comment=Automatic CPU speed & power optimizer for Linux
-Exec=auto-cpufreq.auto-cpufreq-gtk
-StartupWMClass=app.py
-Terminal=false
-Icon=${SNAP}/meta/gui/auto-cpufreq.png
-Categories=System;

snap/snapcraft.yaml

@@ -1,5 +1,5 @@
 name: auto-cpufreq
-base: core22
+base: core20
 summary: Automatic CPU speed & power optimizer for Linux
 description: |
   Automatic CPU speed & power optimizer for Linux based on active
@@ -14,30 +14,22 @@ adopt-info: auto-cpufreq
 
 compression: lzo
 
-architectures:
-  - build-on: [amd64]
-    build-for: [amd64]
-  - build-on: [amd64]
-    build-for: [arm64]
-
 parts:
   auto-cpufreq:
     plugin: python
     python-packages:
        - setuptools
        - wheel
-       - requests
     build-packages:
        - gcc
        - python3-dev
     stage-packages:
        - coreutils
        - dmidecode
-       - pkexec
     source: .
     override-pull: |
       snapcraftctl pull
-      snapcraftctl set-version `grep ^version $SNAPCRAFT_PART_SRC/pyproject.toml | sed 's/.*"\(.*\)"/\1/'`
+      snapcraftctl set-version `grep ^VERSION $SNAPCRAFT_PART_SRC/setup.py | sed 's/.*"\(.*\)"/\1/'`
 
   deploy-scripts:
     plugin: dump
@@ -46,10 +38,6 @@ parts:
       cpufreqctl.sh: usr/bin/cpufreqctl.auto-cpufreq
       snapdaemon.sh: usr/bin/snapdaemon
 
-  copy-image:
-    plugin: dump
-    source: images
-
 plugs:
    etc-auto-cpufreq-conf:
     interface: system-files
@@ -70,28 +58,13 @@ apps:
       - hardware-observe
       - etc-auto-cpufreq-conf
 
-  auto-cpufreq-gtk:
-    command: bin/auto-cpufreq-gtk
-    extensions: [gnome]
-    environment:
-      PYTHONPATH: $SNAP/usr/lib/python3/site-packages:$SNAP/usr/lib/python3/dist-packages:$PYTHONPATH
-      LC_ALL: C.UTF-8
-      LANG: C.UTF-8
-      PKG_MARKER: SNAP
-    plugs:
-      - cpu-control
-      - system-observe
-      - hardware-observe
-      - desktop
-      - desktop-legacy
-      - wayland
-      - x11
   service:
     command: usr/bin/snapdaemon
     plugs:
       - cpu-control
       - system-observe
       - hardware-observe
+      - etc-auto-cpufreq-conf
     environment:
       LC_ALL: C.UTF-8
       LANG: C.UTF-8