pwr_tray 1.0.2__py3-none-any.whl

pwr_tray/IniTool.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+TBD
+"""
+# pylint: disable=invalid-name, broad-exception-caught
+# pylint: disable=too-many-branches,too-many-statements
+# pylint: disable=too-many-instance-attributes
+# pylint: disable=consider-using-from-import
+# pylint: disable=
+# pylint: disable=
+
+import os
+import configparser
+from types import SimpleNamespace
+import copy
+import json
+from pwr_tray.Utils import prt
+
+class IniTool:
+    """ Configued Params for this class"""
+    def __init__(self, paths_only=False):
+        self.defaults = {
+            'Settings': {
+                'i3lock_args': '-t -i ./lockpaper.png',
+                'swaylock_args': '-i ./lockpaper.png',
+                'debug_mode': False,
+                'power_down': False,
+                'turn_off_monitors': False,
+                'lock_min_list': '[15, 30]',
+                'sleep_min_list': '[5, 30]',
+                'lo_battery_pct': 10,
+                'gui_editor': 'geany',
+            #   'dim_pct_brightness': 100,
+            #   'dim_pct_lock_min': 100,
+
+            }, 'HiBattery': { #was OnBattery
+                'power_down': False,
+                'lock_min_list': '[10, 20]',
+                'sleep_min_list': '[1, 10]',
+            #   'dim_pct_brightness': 50,
+            #   'dim_pct_lock_min': 70,
+
+            }, 'LoBattery': {
+                'power_down': True,
+                'lock_min_list': '[1]',
+                'sleep_min_list': '[1]',
+            #   'dim_pct_brightness': 50,
+            #   'dim_pct_lock_min': 70,
+            }
+        }
+        self.folder = os.path.expanduser("~/.config/pwr-tray")
+        self.ini_path =  os.path.join(self.folder, "config.ini")
+        self.log_path =  os.path.join(self.folder, "debug.log")
+        self.picks_path =  os.path.join(self.folder, "picks.json")
+        self.config = configparser.ConfigParser()
+        self.last_mod_time = None
+        self.section_params = {'Settings': {}, 'HiBattery': {}, 'LoBattery': {}, }
+        self.params_by_selector = {}
+        if not paths_only:
+            self.ensure_ini_file()
+            os.chdir(self.folder)
+
+    @staticmethod
+    def get_selectors():
+        """ Returns the in right "order" """
+        return 'Settings HiBattery LoBattery'.split()
+
+    def the_default(self, selector, key):
+        """ return the default value given the selector and key """
+        return self.defaults[selector][key]
+
+    def get_current_vals(self, selector, list_name):
+        """ Expecting a list of two or more non-zero ints """
+        if selector in self.params_by_selector and hasattr(self.params_by_selector[selector], list_name):
+            vals = getattr(self.params_by_selector[selector], list_name)
+            if isinstance(vals, list) and len(vals) >= 2:
+                return vals
+        return self.the_default(selector, list_name) # should not get here
+
+    def get_rotated_vals(self, selector, list_name, first):
+        """ TBD """
+        vals = self.get_current_vals(selector, list_name)
+        if first in vals:
+            while vals[0] != first:
+                vals = vals[1:] + vals[:1]
+            setattr(self.params_by_selector[selector], list_name, vals)
+        return vals
+
+    def ensure_ini_file(self):
+        """Check if the config file exists, create it if not."""
+        if not os.path.exists(self.folder):
+            os.makedirs(self.folder, exist_ok=True)
+        if not os.path.exists(self.ini_path):
+            self.config.read_dict(self.defaults)
+            with open(self.ini_path, 'w', encoding='utf-8') as configfile:
+                self.config.write(configfile)
+
+    def update_config(self):
+        """ Check if the file has been modified since the last read """
+        def to_array(val_str):
+            # Expecting string of form: "[1,2,...]" or just "20"
+            try:
+                vals = json.loads(val_str)
+            except Exception:
+                return None
+            if isinstance(vals, int):
+                vals = [vals]
+            if not isinstance(vals, list):
+                return None
+            rvs = []
+            for val in vals:
+                if isinstance(val, int) and val > 0:
+                    rvs.append(val)
+            if not rvs:
+                return None
+            if len(rvs) == 1: # always want two
+                rvs.append(vals[0])
+            return rvs
+
+        current_mod_time = os.path.getmtime(self.ini_path)
+        if current_mod_time == self.last_mod_time:
+            return False # not updated
+        # Re-read the configuration file if it has changed
+        self.config.read(self.ini_path)
+        self.last_mod_time = current_mod_time
+
+        goldens = self.defaults['Settings']
+        running = goldens
+        all_params = {}
+
+        # Access the configuration values in order
+        prt('parsing config.ini...')
+        for selector in self.get_selectors():
+            all_params[selector] = params = copy.deepcopy(running)
+            if selector not in self.config:
+                all_params[selector] = SimpleNamespace(**params)
+                continue
+
+            # iterate the candidates
+            candidates = dict(self.config[selector])
+            for key, value in candidates.items():
+                if key not in goldens:
+                    prt(f'skip {selector}.{key}: {value!r} [unknown key]')
+                    continue
+
+                if key.endswith('_list'):
+                    list_value = to_array(value)
+                    if not value:
+                        params[key] = self.the_default(selector, key)
+                        prt(f'skip {selector}.{key}: {value!r} [bad list spec]')
+                    else:
+                        params[key] = list_value
+                    continue
+
+                if isinstance(goldens[key], bool):
+                    if isinstance(value, str):
+                        if value.lower() == 'true':
+                            value = True
+                        elif value.lower() == 'false':
+                            value = False
+                    if isinstance(value, bool):
+                        params[key] = value
+                    else:
+                        params[key] = self.the_default(selector, key)
+                        prt(f'skip {selector}.{key}: {value!r} [expecting bool]')
+                    continue
+
+                if isinstance(goldens[key], int):
+                    try:
+                        params[key] = int(value)
+                        continue
+                    except Exception:
+                        params[key] = self.the_default(selector, key)
+                        prt(f'skip {selector}.{key}: {value!r} [expecting int repr]')
+                        continue
+
+                if isinstance(goldens[key], str):
+                    if isinstance(value, str):
+                        params[key] = value
+                    else:
+                        params[key] = self.the_default(selector, key)
+                        prt(f'skip {selector}.{key}: {value!r} [expecting string]')
+                    continue
+
+                assert False, f'unhandled goldens[{key}]: {value!r}'
+            all_params[selector] = SimpleNamespace(**params)
+
+        self.params_by_selector = all_params
+
+        prt('DONE parsing config.ini...')
+
+        return True # updated

pwr_tray/SwayIdleMgr.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Sway does not provide a way to get the idle time, and so the fundamental design
+of pwr-tray using idle time does nto work.  Instead, for sway, we must basically
+set up swayidle to run our config, and if there are special actions like
+blank now, we have to kill the running swayidle and start one that does what
+we want.
+"""
+# pylint: disable=invalid-name,consider-using-with
+import subprocess
+import time
+import os
+import signal
+from types import SimpleNamespace
+from pwr_tray.Utils import prt
+
+class SwayIdleManager:
+    """ Class to manage 'swayidle' """
+    def __init__(self, applet):
+        self.process = None
+        self.applet = applet
+        self.current_cmd = ''
+        # we construct the sway idle from these clauses which various
+        # substitutions.
+        self.clauses = SimpleNamespace(
+            leader="""exec swayidle""",
+            locker=""" timeout [lock_s] '[screenlock] [lockopts]'""",
+            blanker=""" timeout [blank_s] 'swaymsg "output * dpms off"'""",
+            sleeper=""" timeout [sleep_s] 'systemctl suspend'""",
+            # dimmer="""\\\n timeout [dim_s] 'brightnessctl set 50%'""", # perms?
+            before_sleep=""" before-sleep '[screenlock] [lockopts]'""",
+            after_resume=""" after-resume '[unblank]'""",
+                        # + """ 'pgrep -x copyq || copyq --start-server hide;"""
+                        # + """ pgrep -x nm-applet || nm-applet [undim][dpmsOn]'""",
+                        # + """ pgrep -x nm-applet || nm-applet [unblank]'""",
+            # undim = """; brightnessctl set 100%""",
+            screenlock = """pkill swaylock ; exec swaylock --ignore-empty-password --show-failed-attempts""",
+            unblank='''; swaymsg "output * dpms on"''',
+        )
+        self.kill_other_swayidle()
+
+    @staticmethod
+    def kill_other_swayidle():
+        """ Kills any stray swayidles"""
+        try:
+            pids = subprocess.check_output(['pgrep', 'swayidle']).decode().split()
+            if pids:
+                subprocess.run(['pkill', 'swayidle'])
+            time.sleep(2) # Wait a moment to ensure processes are terminated
+
+            pids = subprocess.check_output(['pgrep', 'swayidle']).decode().split()
+            if pids:
+                prt(f"Force killing remaining swayidle processes... {pids}")
+                for pid in pids:
+                    os.kill(int(pid), signal.SIGKILL)
+            return
+        except Exception:
+            return # none left
+
+    def build_cmd(self, mode=None):
+        """ Build the swayidle command line from the current statue. """
+
+        # lock_s, lockopts, sleep_s, blank_s, dim_s = None, '', None, None, None
+        lock_s, lockopts, sleep_s, blank_s = None, '', None, None
+        mode = mode if mode else self.applet.get_effective_mode()
+        til_sleep_s, sleeping = None, False
+
+        lockopts = self.applet.get_params().swaylock_args
+        quick = self.applet.quick
+        a_minute = 30 if quick else 60
+
+        if mode in ('LockOnly', 'SleepAfterLock'):
+            lock_s = self.applet.get_lock_min_list()[0] * a_minute
+            til_sleep_s = lock_s
+            if self.applet.get_params().turn_off_monitors:
+                blank_s = 20 + lock_s
+        if mode in ('SleepAfterLock', ):
+            sleep_s = self.applet.get_sleep_min_list()[0] * a_minute
+            til_sleep_s = sleep_s
+            sleeping = True
+
+        til_sleep_s, blanking = 0, False
+        cmd = self.clauses.leader
+        if isinstance(lock_s, (int,float)) and lock_s >= 0:
+            til_sleep_s += lock_s
+            cmd += self.clauses.locker.replace(
+                "[lock_s]", str(lock_s)).replace(
+                '[lockopts]', lockopts).replace(
+                '[screenlock]', self.clauses.screenlock)
+        if sleeping:
+            til_sleep_s += sleep_s
+            cmd += self.clauses.sleeper.replace("[sleep_s]", str(til_sleep_s))
+        if blank_s is not None:
+            blanking = True
+            cmd += self.clauses.blanker.replace('[blank_s]', str(blank_s))
+#       if isinstance(dim_s, (int,float)) and dim_s >= 0:
+#           dimming = True
+#           cmd += self.clauses.dimmer.replace('[dim_s]', str(dim_s))
+        cmd += self.clauses.before_sleep.replace(
+             "[sleep_s]", str(til_sleep_s)).replace(
+                 '[lockopts]', lockopts).replace(
+                 '[screenlock]', self.clauses.screenlock)
+#       cmd += self.clauses.after_resume.replace(
+#            "[undim]", self.clauses.undim if dimming else '')
+        if blanking:
+            cmd += self.clauses.after_resume.replace(
+                 "[unblank]", self.clauses.unblank if blanking else '')
+
+        rv, self.current_cmd = bool(cmd != self.current_cmd), cmd
+        if rv:
+            prt('NEW-SWAYIDLE:', self.current_cmd)
+
+        return rv # whether updated
+
+    def start(self):
+        """ Build and start the command from the current state """
+        updated = self.build_cmd()
+        if self.process and updated:
+            self.stop()
+        if updated:
+            prt(f'SWAYIDLE: {self.current_cmd}')
+
+        if not self.process and self.current_cmd:
+            self.process = subprocess.Popen(self.current_cmd, shell=True)
+
+        return self.process
+
+    def stop(self):
+        """ Stop the current swayidle (normally to replace it) """
+        self.process.terminate()
+        self.process.wait()
+        self.process = None
+
+    def checkup(self):
+        """ Check whether swayidle is running, normally to restart it
+        with the current command. """
+        if self.process.poll() is not None:
+            self.start()

pwr_tray/Utils.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Utility functions
+"""
+# pylint: disable=invalid-name,broad-exception-caught
+# pylint: disable=consider-using-with,global-statement
+# pylint: disable=too-few-public-methods
+
+import os
+import sys
+import stat
+import time
+import signal
+import shutil
+import subprocess
+import inspect
+from datetime import datetime
+from io import StringIO
+
+import importlib.resources as pkg_resources
+# from pathlib import Path
+
+prt_kb = 512
+prt_path = ''
+prt_to_init = True
+
+def copy_to_folder(resource_name, dest):
+    """ Get the path of a resource """
+    with pkg_resources.path('pwr_tray.resources', resource_name) as file_path:
+        shutil.copy(file_path, os.path.join(dest, resource_name))
+    return file_path
+
+
+def where(above=0):
+    """Get the file and line of the caller. Arguments:
+     -  above -- how many frames to go up (or down) from the reference
+        frame (which is 2 above). above=0 means the caller of the
+        caller of the function (which is the frame ofkjk interest usually).
+    Then keep going up until we get out of this file if possible
+    Returns:
+        [file:line]
+    """
+    stack, frameNo = inspect.stack(), 2 + above
+    if frameNo < 0 or len(stack) < frameNo + 2:
+        return '[n/a]'
+    filename, line_number = stack[frameNo][1:3]
+        # lg.db(f'YES {os.path.basename(filename)}:{line_number}')
+    return f'[{filename.split("/")[-1]}:{line_number}]'
+    # return f'[:{line_number}]'
+
+
+def prt(*args, **kwargs):
+    """ Our custom print routine ...
+     - use instead of print() to get time stamps.
+     - unless stdout is a tty, say for debugging, ~/.config/pwr-tray/debug.log is used for stdout
+     - if we create a log file, its size is limited to 512K and then it is truncated
+     """
+    def check_stdout(use_stdout=None):
+        global prt_to_init
+        def is_tty():
+            try:
+                os.ttyname(sys.stdout.fileno())
+                return True
+            except Exception:
+                return False
+        def is_reg():
+            try:
+                return stat.S_ISREG(os.fstat(sys.stdout.fileno()).st_mode)
+            except Exception:
+                return False
+        def reopen():
+            global prt_to_init
+            sys.stdout = open(prt_path, "a+", encoding='utf-8')
+            sys.stderr = sys.stdout
+            os.dup2(sys.stdout.fileno(), 1)
+            os.dup2(sys.stderr.fileno(), 2)
+            prt_to_init = False
+
+        if prt_kb > 0 and prt_path: # non-positive disables stdout "tuning"
+            if use_stdout is False:
+                reopen()
+            elif prt_to_init and sys.stdout.closed: # Check if stdout is closed
+                reopen()
+            elif prt_to_init and not is_tty() and not is_reg():
+                reopen()
+            if os.fstat(sys.stdout.fileno()).st_size > prt_kb*1024:
+                shutil.move(prt_path, f'{prt_path}1')
+                reopen()
+
+    to_stdout = None
+    if 'to_stdout' in kwargs:
+        to_stdout = bool(kwargs['to_stdout'])
+        del kwargs['to_stdout']
+    check_stdout(to_stdout)
+
+    dt = datetime.now().strftime('%m-%d^%H:%M:%S')
+    s = StringIO()
+    print(dt, end=' ', file=s)
+    kwargs['end'] = ' '
+    kwargs['file'] = s
+    print(*args, **kwargs)
+    string = f'{s.getvalue()} {where()}'
+    print(string, flush=True)
+
+def x_restart_self():
+    """ TBD """
+    # Retrieve the current script name and arguments
+    script_name = sys.argv[0]
+    script_args = sys.argv[1:]
+
+    # Use subprocess to run the script with the same arguments
+    subprocess.run([sys.executable, script_name] + script_args, check=True)
+
+class PyKill:
+    """Class to kill python scripts and explain how; avoids suicide. """
+    def __init__(self):
+        self.last_sig = {} # keyed by target
+        self.alive = {} # ps line of found targets
+
+    def _kill_script(self, targets, sig):
+        """ one iteration through very instance of the remaining processes """
+        def kill_pid(pid, sig):
+            # terminate the process
+            alive = True
+            try:
+                os.kill(pid, sig)
+            except OSError:
+                alive = False
+            return alive
+        self.alive = {} # reset each time thru
+        for line in os.popen("ps -eo pid,args"):
+            words = line.split()
+            if len(words) < 3:
+                continue
+            pid, cmd = int(words[0]), os.path.basename(words[1])
+            if pid == os.getpid():
+                continue  # no suicides
+            script = os.path.basename(words[2])
+            for target in targets:
+                if cmd in ('python', 'python3') and script in (target, f'{target}.py'):
+                    self.last_sig[target] = sig
+                    if kill_pid(pid, sig): # returns True if alive
+                        self.alive[target] = line
+        return self.alive
+
+    def kill_loop(self, targets):
+        """Loops thru the remaining process until all or gone or we
+        become exhausted (e.g., unkillable processes)."""
+        targets = targets if isinstance(targets, (list, tuple)) else [targets]
+        for sig in [signal.SIGTERM, signal.SIGTERM, signal.SIGTERM,
+                    signal.SIGKILL, signal.SIGKILL,]:
+            if not self._kill_script(targets, sig):
+                break
+            time.sleep(1)
+        for target, line in self.alive.items():
+            prt(f'ALERT: running: {line} [sig={self.last_sig[target]}]')
+        for target in targets:
+            if target in self.alive:
+                continue
+            prt(f'INFO: gone: {target} [sig={self.last_sig.get(target, None)}]')
+        return not bool(self.alive)

pwr_tray/YamlDump.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Dump (almost) any object in YAML format.
+Supports mixing flow / non-flow nodes to handles cases where non-flow makes the
+dump have an absurd line count with many trite lines.
+
+This *may* require customization if types are used for which this does not work;
+search for 'YourClassThatDoesNotWork' to see where to customize your outlier cases.
+
+"""
+# pylint: disable=invalid-name
+
+import threading
+import textwrap
+from io import StringIO
+from collections import OrderedDict
+from ruamel.yaml import YAML, comments as yaml_comments
+from LibGen.CustLogger import CustLogger as lg
+# import ToolBase as tb
+
+#yaml = YAML(typ='safe') # NOTE: cannot have 'safe' and mixed block/flow style
+yaml = YAML()
+yaml.default_flow_style = False
+
+flow = threading.local()
+flow.flow_nodes = None
+
+def yamlize(obj):
+    """Make a complex object (e.g., class objects) more capable of
+    being dumped in yaml by simplifying the types where possible."""
+    # pylint: disable=too-many-return-statements
+    if isinstance(obj, list):
+        rv = []
+        for value in obj:
+            rv.append(yamlize(value))
+        return rv
+
+    if isinstance(obj, dict):
+        rv = OrderedDict()
+        for key, value in obj.items():
+            rv[key] = yamlize(value)
+        return rv
+
+    # this handles some crazy types like:
+    #   rumel.yaml.scalarfloat.ScalarFloat
+    # when the object was converted from yaml
+    if isinstance(obj, bool):
+        return bool(obj)
+    if isinstance(obj, int):
+        return int(obj)
+    if isinstance(obj, float):
+        return float(obj)
+#   NOTE: if there are objects not handled, then fix here
+#   if isinstance(obj, YourClassThatDoesNotWork):
+#       return str(obj) # or whatever type if str is not appropriate
+
+    # convert a potentially recursive object into a dictionary
+    # - ignore variables that start with '_'
+    if not hasattr(obj, '__dict__'):
+        return obj
+    raw_rv = vars(obj)
+    rv = {}
+    for key, val in raw_rv.items():
+        if key.startswith('_'):
+            continue
+        rv[key] = yamlize(val)
+    return rv
+
+def set_flow(obj, flow_nodes=None):
+    """Set flow style for certain nodes...
+    Ref: https://stackoverflow.com/questions/63364894/
+        how-to-dump-only-lists-with-flow-style-with-pyyaml-or-ruamel-yaml
+    """
+    obj = yamlize(obj)
+    if flow_nodes:
+        flow.flow_nodes = flow_nodes
+        set_flow_recursive(obj)
+    return obj
+
+def set_flow_recursive(obj):
+    """TBD"""
+    if isinstance(obj, dict):
+        # print('dict...')
+        for key, value in obj.items():
+            # print('key...', key)
+            if key in flow.flow_nodes:
+                if isinstance(value, dict):
+                    # print('...', key, '/map')
+                    value = yaml_comments.CommentedMap(value)
+                    value.fa.set_flow_style()
+                    obj[key] = value
+                elif isinstance(value, list):
+                    # print('...', key, '/list')
+                    value = yaml_comments.CommentedSeq(value)
+                    value.fa.set_flow_style()
+                    obj[key] = value
+            else:
+                set_flow_recursive(value)
+    elif isinstance(obj, list):
+        # print('list...')
+        for value in obj:
+            set_flow_recursive(value)
+
+def yaml_to_file(obj, fileh, flow_nodes=None):
+    """Do a yaml-to-file conversion of an object (w/o indent)."""
+    obj = set_flow(obj, flow_nodes)
+    yaml.dump(obj, fileh)
+
+def yaml_str(obj, indent=8, width=70, flow_nodes=None):
+    """Do a yaml-to-string conversion of an object with indent by default."""
+    outs = StringIO()
+    obj = set_flow(obj, flow_nodes)
+    old_width, yaml.width = yaml.width, width
+    yaml.dump(obj, outs)
+    yaml.width = old_width
+    return textwrap.indent(outs.getvalue(), prefix=' '*indent)
+
+def yaml_dump(obj, indent=8, flow_nodes=None):
+    """Do a yaml dump of an object to stdout with indent by default1."""
+    lg.pr(yaml_str(obj, indent=indent, flow_nodes=flow_nodes).rstrip())
+
+
+def runner(argv):
+    """Several simple tests for YamlDump including exercising flow_nodes."""
+    # pylint: disable=broad-except, import-outside-toplevel, using-constant-test
+    def tester_func():
+        """TBD"""
+        import sys
+        import copy
+
+        scrum_orig = {'flow_sec': 55, 'hash': 'cb217daa4aedf6ad8483a9333f6cc114f413cc7b',
+                'name': 'Eche Palante - Refle', 'progress': 100, 'ratio': 0.8502833247184753,
+                'samples': [[10.9, 10, 2.02], [15.7, 23, 1.14], [18.1, 32, 1.06],
+                    [20.5, 42, 0.91], [22.9, 50, 0.93], [30.1, 65, 0.98], [34.9, 75, 0.91],
+                    [39.7, 83, 0.88], [44.5, 90, 0.89], [54.1, 100, 0.85]],
+                'scrum_form_sec': 8, 'scrum_sz': 12, 'time': 1621850682.8617778,
+                'tor_sz': 249262127, 'up_client': 'qBittorrent/4.3.5', 'up_sec': 0}
+
+        if True:
+            scrum = copy.deepcopy(scrum_orig)
+            print('\n\n===== TEST 1:', 'yaml.dump(scrum, sys.stdout)')
+            yaml.dump(scrum, sys.stdout)
+
+        if True:
+            scrum = copy.deepcopy(scrum_orig)
+            print('\n\n===== TEST 2:', 'surgical CommentedSeq')
+            obj = yaml_comments.CommentedSeq(scrum['samples'])
+            obj.fa.set_flow_style()
+            scrum['samples'] = obj
+            yaml.dump(scrum, sys.stdout)
+
+        if True:
+            scrum = copy.deepcopy(scrum_orig)
+            print('\n\n===== TEST 3:', 'designed API')
+            yaml_dump(scrum, flow_nodes=('samples',))
+
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-V', '--log-level', choices=lg.choices,
+            default='INFO', help='set logging/verbosity level [dflt=INFO]')
+    opts = parser.parse_args(argv)
+    lg.setup(level=opts.log_level)
+    tester_func()