"Session" management (or how to persist windows between Qtile shutdowns)

[ervinpopescu]

After some deliberation in #4844, I came up with this:

import json
import psutil
import os

from modules.path import config_path
from libqtile import hook, qtile

from libqtile.backend.base import Window
from libqtile.core.manager import Qtile
from libqtile.log_utils import logger

qtile: Qtile

excluded_apps = ["plank"]

class Session:
    def __init__(self):
        self.apps: list[dict[int, str]] = []
        self.save_path = os.path.join(config_path, "json", "session.json")
        if not os.path.exists(self.save_path):
            self.from_windows()
        else:
            self.restore()

    def add_app(self, wid: int, exe: str):
        if not (any(app["wid"] == wid for app in self.apps) or any(i in exe for i in excluded_apps) or qtile.windows_map[wid].group.name == "scratchpad"):
            logger.info("Adding %s to session", exe)
            self.apps.append({"wid": wid, "exe": exe})
        else:
            logger.info("NOT adding excluded app %s to session", exe)
        self.log()

    def remove_app(self, wid: int):
        for i in range(len(self.apps)):
            if self.apps[i]["wid"] == wid:
                exe = next((app["exe"] for app in self.apps if app["wid"] == wid), None)
                logger.info("Removing %s from session", exe)
                del self.apps[i]
                break
        self.log()

    def save(self):
        with open(self.save_path, "w") as f:
            json.dump(self.apps, f)
        apps = [app["exe"] for app in self.apps]
        logger.info("Saving session with apps: %s", ",".join(apps))

    def restore(self):
        with open(self.save_path, "r") as f:
            self.apps = json.load(f)

    def clear(self):
        self.log()
        logger.info("Clearing session")
        self.apps = []
        self.log()

    def from_windows(self):
        self.log()
        logger.info("Setting session from current windows")
        windows = qtile.windows()
        if windows:
            for window in windows:
                wid = window["id"]
                exe = psutil.Process(int(qtile.windows_map[wid].get_pid())).exe()
                self.add_app(
                    wid=wid,
                    exe=exe,
                )
        self.log()

    def log(self):
        logger.info("Session: %s", self.apps)


session = Session()

# @hook.subscribe.startup
# def set_loglevel():
#     qtile.info()

@hook.subscribe.startup_once
def restore_session():
    apps = [app["exe"] for app in session.apps]
    logger.info("Restoring session with apps: %s", ",".join(apps))
    for app in apps:
        qtile.spawn(app)

@hook.subscribe.client_managed
def add_app_to_session(client: Window):
    wid = client.info()["id"]
    exe = psutil.Process(client.window.get_net_wm_pid()).exe()
    session.add_app(wid, exe)

@hook.subscribe.client_killed
def remove_app_from_session(client: Window):
    wid = client.info()["id"]
    session.remove_app(wid)

@hook.subscribe.shutdown
@hook.subscribe.user("save_session")
def save_session():
    session.save()

@hook.subscribe.user("get_session")
def log_session():
    session.log()

@hook.subscribe.user("set_session")
def set_session():
    session.from_windows()

@hook.subscribe.user("clear_session")
def clear_session():
    session.clear()
    if os.path.exists(session.save_path):
        os.remove(session.save_path)

If anyone is reading this code and has a better idea/thinks that this code can look/be better, please feel free to let me know.