umu-commander 2.0.0__py3-none-any.whl

umu_commander/Types/__init__.py

@@ -0,0 +1,18 @@
+from enum import IntEnum
+
+
+class Element(str):
+    def __new__(cls, value: str, name: str = None):
+        instance = super().__new__(cls, value)
+        if name is None:
+            instance.name = value
+        else:
+            instance.name = name
+
+        return instance
+
+
+class ExitCode(IntEnum):
+    SUCCESS = 0
+    DECODING_ERROR = 1
+    INVALID_SELECTION = 2

umu_commander/__init__.py

@@ -0,0 +1 @@
+VERSION = "v2.0.0"

umu_commander/__main__.py

@@ -0,0 +1,205 @@
+import argparse
+import sys
+from argparse import ArgumentParser, Namespace
+from json import JSONDecodeError
+from pathlib import Path
+
+from InquirerPy.exceptions import InvalidArgument
+
+from umu_commander import VERSION
+from umu_commander import configuration as config
+from umu_commander import database as db
+from umu_commander import tracking, umu_config
+from umu_commander.configuration import CONFIG_DIR, CONFIG_NAME, DEFAULT_UMU_CONFIG_NAME
+from umu_commander.Types import ExitCode
+
+
+def init() -> ExitCode:
+    try:
+        config.load()
+
+    except (JSONDecodeError, KeyError):
+        config_path: Path = CONFIG_DIR / CONFIG_NAME
+        config_path_old: Path = CONFIG_DIR / (str(CONFIG_NAME) + ".old")
+
+        print(f"Config file at {config_path} could not be read.")
+
+        if not config_path_old.exists():
+            print(f"Config file renamed to {config_path_old}.")
+            config_path.rename(config_path_old)
+
+        return ExitCode.DECODING_ERROR
+
+    except FileNotFoundError:
+        config.dump()
+
+    try:
+        db.load()
+
+    except JSONDecodeError:
+        db_path: Path = config.DB_DIR / config.DB_NAME
+        db_path_old: Path = config.DB_DIR / (str(config.DB_NAME) + ".old")
+
+        print(f"Tracking file at {db_path} could not be read.")
+
+        if not db_path_old.exists():
+            db_path.rename(db_path_old)
+            print(f"DB file renamed to {db_path_old}.")
+
+    except FileNotFoundError:
+        pass
+
+    return ExitCode.SUCCESS
+
+
+def get_parser_results() -> tuple[ArgumentParser, Namespace]:
+    parser = argparse.ArgumentParser(
+        prog=f"umu-commander",
+        description="Interactive CLI tool to augment umu-launcher",
+        epilog="For details, usage, and more, see the README.md file, or visit https://github.com/Mpaxlamitsounas/umu-commander.",
+        add_help=True,
+    )
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {VERSION}",
+        help="Prints this menu.",
+    )
+    parser.add_argument(
+        "-q",
+        "--quiet",
+        action="store_true",
+        help="Suppresses all non interactive output.",
+    )
+    parser.add_argument(
+        "verb",
+        help="Selects program functionality.",
+        choices=["track", "untrack", "users", "delete", "create", "run", "fix"],
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        help=f'Path to file or directory that will be acted upon. Default: $PWD for directories, "{DEFAULT_UMU_CONFIG_NAME}" for files',
+        type=Path,
+    )
+    parser.add_argument(
+        "-pr",
+        "--proton",
+        help="Path to Proton version that will be used. Default: Latest umu proton",
+        type=Path,
+    )
+    parser.add_argument(
+        "-wp",
+        "--wine-prefix",
+        help='Sets the WINE prefix path in config creation. Default: directory/"prefix"',
+        type=Path,
+        dest="prefix",
+    )
+    parser.add_argument(
+        "-dll",
+        "--dll-overrides",
+        help="Sets the WINE DLL override string in config creation. Default: No overrides",
+    )
+    parser.add_argument(
+        "-l",
+        "--lang",
+        help="Sets the language locale override in config creation. Default: No override",
+    )
+    parser.add_argument(
+        "-a",
+        "--launch_args",
+        help="Sets launch arguments in config creation. Default: No arguments",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        help=f"Sets output config filename in config creation. Default directory/{DEFAULT_UMU_CONFIG_NAME}",
+        type=Path,
+    )
+    parser.add_argument(
+        "-ni",
+        "--no-interactive",
+        help="Uses defaults for missing values instead of prompting.",
+        action="store_false",
+        dest="interactive",
+    )
+    parser.add_argument(
+        "-nr",
+        "--no-refresh",
+        "-nu",
+        "--no-update",
+        help="Do not check for new Proton versions while running.",
+        action="store_false",
+        dest="refresh",
+    )
+
+    args = parser.parse_args()
+
+    return parser, args
+
+
+def main() -> int:
+    if (return_code := init()) != ExitCode.SUCCESS:
+        return return_code.value
+
+    parser, args = get_parser_results()
+
+    try:
+        match args.verb:
+            case "track":
+                tracking.track(
+                    args.proton,
+                    args.input,
+                    refresh_versions=args.refresh,
+                    quiet=args.quiet,
+                )
+
+            case "untrack":
+                tracking.untrack(args.input, quiet=args.quiet)
+
+            case "users":
+                tracking.users(args.proton)
+
+            case "delete":
+                tracking.delete()
+
+            case "create":
+                umu_config.create(
+                    args.prefix,
+                    args.proton,
+                    args.dll_overrides,
+                    args.lang,
+                    args.launch_args,
+                    args.input,
+                    args.output,
+                    interactive=args.interactive,
+                    refresh_versions=args.refresh,
+                    quiet=args.quiet,
+                )
+
+            case "run":
+                umu_config.run(args.input)
+
+            case "fix":
+                umu_config.fix(args.input)
+
+            case _:
+                print("Unrecognised verb.")
+                parser.print_help()
+                return ExitCode.INVALID_SELECTION.value
+
+    except InvalidArgument:
+        print("No choices to select from.")
+        return ExitCode.INVALID_SELECTION.value
+
+    else:
+        return ExitCode.SUCCESS.value
+
+    finally:
+        tracking.untrack_unlinked()
+        db.dump()
+
+
+if __name__ == "__main__":
+    exit(main())

umu_commander/configuration.py

@@ -0,0 +1,94 @@
+import importlib
+import os
+import tomllib
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+from umu_commander.Types import Element
+
+CONFIG_DIR: Path = Path.home() / ".config"
+CONFIG_NAME: Path = Path("umu-commander.toml")
+
+PROTON_PATHS: tuple[Path, ...] = (
+    Path.home() / ".local/share/Steam/compatibilitytools.d",
+    Path.home() / ".local/share/umu/compatibilitytools",
+    Path.home()
+    / ".var/app/com.valvesoftware.Steam/.local/share/Steam/compatibilitytools.d",
+)
+UMU_PROTON_PATH: Path = Path(Path.home() / ".local/share/Steam/compatibilitytools.d")
+
+DB_NAME: Path = Path("tracking.json")
+DB_DIR: Path = Path.home() / ".local/share/umu/compatibilitytools"
+DEFAULT_UMU_CONFIG_NAME: Path = Path("umu-config.toml")
+DEFAULT_PREFIX_DIR: Path = Path.home() / ".local/share/wineprefixes/"
+DLL_OVERRIDES_OPTIONS: tuple[Element, ...] = (
+    Element("winhttp.dll=n,b;", "winhttp for BepInEx"),
+)
+LANG_OVERRIDES_OPTIONS: tuple[Element, ...] = (Element("ja_JP.UTF8", "Japanese"),)
+
+module = importlib.import_module(__name__)
+
+
+def load():
+    with open(os.path.join(CONFIG_DIR, CONFIG_NAME), "rb") as conf_file:
+        toml_conf = tomllib.load(conf_file)
+
+        # Proton dirs translation
+        setattr(
+            module,
+            "PROTON_PATHS",
+            (Path(proton_dir) for proton_dir in toml_conf["PROTON_PATHS"]),
+        )
+        del toml_conf["PROTON_PATHS"]
+
+        # DLL/LANG Override translation
+        for key in ["DLL", "LANG"]:
+            setattr(
+                module,
+                f"{key}_OVERRIDES_OPTIONS",
+                (
+                    Element(value, name)
+                    for name, value in toml_conf[f"{key}_OVERRIDES_OPTIONS"].items()
+                ),
+            )
+            del toml_conf[f"{key}_OVERRIDES_OPTIONS"]
+
+        for key, value in toml_conf.items():
+            setattr(module, key, Path(value))
+
+
+def _get_attributes() -> dict[str, Any]:
+    attributes: dict[str, Any] = {}
+    for key in dir(module):
+        value = getattr(module, key)
+        if not key.startswith("_") and not callable(value) and key.upper() == key:
+            attributes[key] = value
+
+    return attributes
+
+
+def dump():
+    if not os.path.exists(CONFIG_DIR):
+        os.mkdir(CONFIG_DIR)
+
+    with open(os.path.join(CONFIG_DIR, CONFIG_NAME), "wb") as conf_file:
+        toml_conf = _get_attributes()
+        del toml_conf["CONFIG_DIR"]
+        del toml_conf["CONFIG_NAME"]
+
+        for key, value in toml_conf.items():
+            match key:
+                case "PROTON_PATHS":
+                    toml_conf[key] = [str(proton_dir) for proton_dir in PROTON_PATHS]
+
+                case "DLL_OVERRIDES_OPTIONS" | "LANG_OVERRIDES_OPTIONS":
+                    toml_conf[key] = {
+                        override.name: override for override in getattr(module, key)
+                    }
+
+                case _:
+                    toml_conf[key] = str(value)
+
+        tomli_w.dump(toml_conf, conf_file)

umu_commander/database.py

@@ -0,0 +1,66 @@
+import json
+from collections import defaultdict
+from pathlib import Path
+
+import umu_commander.configuration as config
+
+_db: defaultdict[Path, defaultdict[Path, list[Path]]] = defaultdict(
+    lambda: defaultdict(list)
+)
+
+
+def load():
+    global _db
+
+    if not config.DB_DIR.exists():
+        config.DB_DIR.mkdir()
+
+    with open(config.DB_DIR / config.DB_NAME, "rt") as db_file:
+        db: dict[Path, dict[Path, list[Path]]] = {}
+        for proton_dir, proton_vers in json.load(db_file).items():
+            proton_dir = Path(proton_dir)
+            db[proton_dir] = {}
+            for proton_ver, proton_users in proton_vers.items():
+                proton_ver = proton_dir / proton_ver
+                db[proton_dir][proton_ver] = [Path(user) for user in proton_users]
+        # noinspection PyTypeChecker
+        _db.update(db)
+
+
+def dump():
+    if not config.DB_DIR.exists():
+        config.DB_DIR.mkdir()
+
+    db: dict[str, dict[str, list[str]]] = {}
+    for proton_dir, proton_vers in _db.items():
+        proton_dir = str(proton_dir)
+        db[proton_dir] = {}
+        for proton_ver, proton_users in proton_vers.items():
+            proton_ver = proton_ver.name
+            db[proton_dir][proton_ver] = [str(user) for user in proton_users]
+
+    with open(config.DB_DIR / config.DB_NAME, "wt") as db_file:
+        # noinspection PyTypeChecker
+        json.dump(db, db_file, indent="\t")
+
+
+def get(
+    proton_dir: Path = None, proton_ver: Path = None
+) -> dict[Path, dict[Path, list[Path]]] | dict[Path, list[Path]] | list[Path]:
+    global _db
+
+    if proton_dir is None and proton_ver is None:
+        return _db
+
+    if proton_ver is None:
+        return _db[proton_dir]
+
+    if proton_ver not in _db[proton_dir]:
+        _db[proton_dir][proton_ver] = []
+
+    return _db[proton_dir][proton_ver]
+
+
+def _reset():
+    global _db
+    _db = defaultdict(lambda: defaultdict(list))

umu_commander/proton.py

@@ -0,0 +1,65 @@
+import re
+import subprocess
+from collections.abc import Iterable
+from pathlib import Path
+
+import umu_commander.configuration as config
+
+
+def _natural_sort_proton_ver_key(p: Path, _nsre=re.compile(r"(\d+)")):
+    s: str = p.name
+    return [int(text) if text.isdigit() else text for text in _nsre.split(s)]
+
+
+def refresh_proton_versions():
+    print("Updating umu Proton.")
+    umu_update_process = subprocess.run(
+        ["umu-run", '""'],
+        env={"PROTONPATH": "UMU-Latest", "UMU_LOG": "debug"},
+        capture_output=True,
+        text=True,
+    )
+
+    for line in umu_update_process.stderr.split("\n"):
+        if "PROTONPATH" in line and "/" in line:
+            try:
+                left: int = line.rfind("/") + 1
+                print(f"Latest UMU-Proton: {line[left:len(line) - 1]}.")
+            except ValueError:
+                print("Could not fetch latest UMU-Proton.")
+
+            break
+
+
+def collect_proton_versions(sort: bool = False) -> dict[Path, Iterable[Path]]:
+    versions: dict[Path, Iterable[Path]] = {}
+    for proton_dir in config.PROTON_PATHS:
+        dir_versions = [version for version in proton_dir.iterdir() if version.is_dir()]
+        if len(dir_versions) == 0:
+            continue
+        else:
+            versions[proton_dir] = dir_versions
+
+        if sort:
+            versions[proton_dir] = sorted(
+                versions[proton_dir], key=_natural_sort_proton_ver_key, reverse=True
+            )
+
+    return versions
+
+
+def get_latest_umu_proton() -> Path | None:
+    umu_proton_versions: list[Path] = [
+        config.UMU_PROTON_PATH / proton_ver
+        for proton_ver in config.UMU_PROTON_PATH.iterdir()
+        if "UMU" in proton_ver.name and (config.UMU_PROTON_PATH / proton_ver).is_dir()
+    ]
+
+    if len(umu_proton_versions) == 0:
+        return None
+
+    umu_proton_versions = sorted(
+        umu_proton_versions, key=_natural_sort_proton_ver_key, reverse=True
+    )
+
+    return umu_proton_versions[0]

umu_commander/tracking.py

@@ -0,0 +1,125 @@
+import shutil
+from pathlib import Path
+
+from InquirerPy import inquirer
+
+import umu_commander.database as db
+from umu_commander.configuration import DEFAULT_UMU_CONFIG_NAME
+from umu_commander.proton import (
+    collect_proton_versions,
+    get_latest_umu_proton,
+    refresh_proton_versions,
+)
+from umu_commander.util import (
+    build_choices,
+)
+
+
+def select_config() -> str:
+    files = [file for file in Path.cwd().iterdir() if file.is_file()]
+    choices = build_choices(files, None)
+    return inquirer.select("Select umu-commander config:", choices).execute()
+
+
+def untrack(target_dir: Path = None, *, quiet: bool = False):
+    if target_dir is None:
+        target_dir = Path.cwd()
+
+    target_dir = target_dir.absolute()
+
+    for proton_dir in db.get().keys():
+        for proton_ver in db.get(proton_dir):
+            if target_dir in db.get(proton_dir, proton_ver):
+                db.get(proton_dir, proton_ver).remove(target_dir)
+
+    if not quiet:
+        print("Directory removed from all tracking lists.")
+
+
+def track(
+    proton_ver: Path = None,
+    config: Path = None,
+    *,
+    interactive: bool = True,
+    refresh_versions: bool = True,
+    quiet: bool = False,
+):
+    if config is None:
+        if interactive:
+            config = select_config()
+
+        else:
+            config = Path.cwd() / DEFAULT_UMU_CONFIG_NAME
+
+    if refresh_versions:
+        refresh_proton_versions()
+
+    if proton_ver is None:
+        proton_dirs = collect_proton_versions(sort=True)
+        choices = build_choices(None, proton_dirs)
+        proton_ver: Path = inquirer.select(
+            "Select Proton version to track directory with:", choices
+        ).execute()
+
+    proton_ver = proton_ver.absolute()
+    config = config.absolute()
+
+    untrack(config, quiet=True)
+    db.get(proton_ver.parent, proton_ver).append(config)
+
+    if not quiet:
+        print(
+            f"Directory {config} added to Proton version's {proton_ver.name} in {proton_ver.parent} tracking list."
+        )
+
+
+def users(proton_ver: Path = None):
+    if proton_ver is None:
+        proton_dirs = collect_proton_versions(sort=True)
+        choices = build_choices(None, proton_dirs, count_elements=True)
+        proton_ver: Path = inquirer.select(
+            "Select Proton version to view user list:", choices
+        ).execute()
+
+    proton_ver = proton_ver.absolute()
+
+    if proton_ver.parent in db.get() and proton_ver in db.get(proton_ver.parent):
+        version_users: list[Path] = db.get(proton_ver.parent, proton_ver)
+        if len(version_users) > 0:
+            print(
+                f"Directories tracked by {proton_ver.name} of {proton_ver.parent}:",
+                *version_users,
+                sep="\n\t",
+            )
+
+        else:
+            print("This version is tracking no directories.")
+
+    else:
+        print("This version hasn't been used by umu before.")
+
+
+def delete():
+    for proton_dir in db.get().keys():
+        for proton_ver, version_users in db.get(proton_dir).copy().items():
+            if proton_ver == get_latest_umu_proton():
+                continue
+
+            if len(version_users) == 0:
+                confirmed: bool = inquirer.confirm(
+                    f"Version {proton_ver.name} in {proton_dir} is tracking no directories, delete?"
+                ).execute()
+                if confirmed:
+                    try:
+                        shutil.rmtree(proton_dir / proton_ver)
+                    except FileNotFoundError:
+                        pass
+                    del db.get(proton_dir)[proton_ver]
+
+
+def untrack_unlinked():
+    for proton_dir in db.get().keys():
+        for proton_ver, version_users in db.get()[proton_dir].items():
+            for user in version_users:
+                if not user.exists():
+                    db.get(proton_dir, proton_ver).remove(user)

umu_commander/umu_config.py

@@ -0,0 +1,203 @@
+import os
+import subprocess
+import tomllib
+from collections.abc import Iterable
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+from InquirerPy import inquirer
+
+import umu_commander.configuration as config
+from umu_commander import database as db
+from umu_commander import tracking
+from umu_commander.configuration import (
+    DEFAULT_UMU_CONFIG_NAME,
+    DLL_OVERRIDES_OPTIONS,
+    LANG_OVERRIDES_OPTIONS,
+)
+from umu_commander.proton import (
+    collect_proton_versions,
+    get_latest_umu_proton,
+    refresh_proton_versions,
+)
+from umu_commander.Types import Element
+from umu_commander.util import build_choices
+
+
+def select_prefix() -> Path:
+    default = Element(str(Path.cwd() / "prefix"), "Current directory")
+    choices = build_choices([default, *config.DEFAULT_PREFIX_DIR.iterdir()], None)
+    return inquirer.select("Select wine prefix:", choices, default).execute()
+
+
+def select_proton() -> Path:
+    choices = build_choices(None, collect_proton_versions(sort=True))
+    return inquirer.select(
+        "Select Proton version:", choices, Path.cwd() / "prefix"
+    ).execute()
+
+
+def select_dll_override() -> str:
+    choices = build_choices(DLL_OVERRIDES_OPTIONS, None)
+    return "".join(
+        [
+            selection
+            for selection in inquirer.checkbox(
+                "Select DLLs to override:", choices
+            ).execute()
+        ]
+    )
+
+
+def select_lang() -> str:
+    default = Element("", "No override")
+    choices = build_choices([default, *LANG_OVERRIDES_OPTIONS], None)
+    return inquirer.select("Select locale:", choices, default).execute()
+
+
+def set_launch_args() -> list[str]:
+    options: str = inquirer.text(
+        "Enter executable options, separated by space:"
+    ).execute()
+    return [opt.strip() for opt in options.split(" ")]
+
+
+def select_exe() -> Path:
+    files = [file for file in Path.cwd().iterdir() if file.is_file()]
+    choices = build_choices(files, None)
+    return inquirer.select("Select game executable:", choices).execute()
+
+
+def create(
+    prefix: Path = None,
+    proton_ver: Path = None,
+    dll_overrides: str = None,
+    lang: str = None,
+    launch_args: Iterable[str] = None,
+    exe: Path = None,
+    output: Path = None,
+    *,
+    interactive: bool = True,
+    refresh_versions: bool = True,
+    quiet: bool = False,
+):
+    if refresh_versions:
+        refresh_proton_versions()
+
+    # Prefix selection
+    if prefix is None:
+        if interactive:
+            prefix = select_prefix()
+
+        else:
+            prefix = Path.cwd() / "prefix"
+
+    # Proton selection
+    if proton_ver is None:
+        if interactive:
+            proton_ver = select_proton()
+
+        else:
+            proton_ver = get_latest_umu_proton()
+
+    # Select DLL overrides
+    if dll_overrides is None and interactive:
+        dll_overrides = select_dll_override()
+
+    # Set language locale
+    if lang is None and interactive:
+        lang = select_lang()
+
+    # Input executable launch args
+    if launch_args is None and interactive:
+        launch_args = set_launch_args()
+
+    # Select executable name
+    if exe is None:
+        exe = select_exe()
+
+    params: dict[str, Any] = {
+        "umu": {
+            "prefix": str(prefix.absolute()),
+            "proton": str(proton_ver.absolute()),
+            "launch_args": launch_args,
+            "exe": str(exe),
+        },
+        "env": {"WINEDLLOVERRIDES": dll_overrides, "LANG": lang},
+    }
+
+    if not params["umu"]["launch_args"]:
+        del params["umu"]["launch_args"]
+
+    if not params["env"]["WINEDLLOVERRIDES"]:
+        del params["env"]["WINEDLLOVERRIDES"]
+
+    if not params["env"]["LANG"]:
+        del params["env"]["LANG"]
+
+    if output is None:
+        output = Path.cwd() / DEFAULT_UMU_CONFIG_NAME
+
+    output = output.absolute()
+
+    try:
+        with open(output, "wb") as file:
+            tomli_w.dump(params, file)
+
+    except (ValueError, TypeError):
+        if not quiet:
+            print("Could not create configuration file.")
+
+    if not quiet:
+        print(f"Configuration file {output.name} created in {output.parent}.")
+        print(f"Use with umu-commander run.")
+
+    tracking.track(proton_ver, output, refresh_versions=False, quiet=quiet)
+
+
+def run(umu_config: Path = None):
+    if umu_config is None:
+        umu_config = Path.cwd() / DEFAULT_UMU_CONFIG_NAME
+
+    if not umu_config.exists():
+        print("Specified umu config does not exist.")
+        return
+
+    with open(umu_config, "rb") as toml_file:
+        toml_conf = tomllib.load(toml_file)
+
+        prefix_path = Path(toml_conf["umu"]["prefix"])
+        if not prefix_path.exists():
+            prefix_path.mkdir()
+
+        os.environ.update(toml_conf.get("env", {}))
+        subprocess.run(
+            args=["umu-run", "--config", config.DEFAULT_UMU_CONFIG_NAME],
+            env=os.environ,
+        )
+
+
+def fix(umu_config: Path = None):
+    if umu_config is None:
+        umu_config = Path.cwd() / DEFAULT_UMU_CONFIG_NAME
+
+    if not umu_config.exists():
+        print("Specified umu config does not exist.")
+        return
+
+    with open(umu_config, "rb") as toml_file:
+        toml_conf = tomllib.load(toml_file)
+
+    base_dir = umu_config.absolute().parent
+    proton = Path(toml_conf["umu"]["proton"])
+    prefix = Path(toml_conf["umu"]["prefix"])
+    if not prefix.exists():
+        if base_dir in db.get(proton.parent, proton):
+            db.get(proton.parent, proton).append(base_dir)
+
+        toml_conf["umu"]["prefix"] = base_dir / prefix.name
+
+    exe = Path(toml_conf["umu"]["prefix"])
+    if not exe.exists():
+        toml_conf["umu"]["exe"] = base_dir / exe.name

umu_commander/util.py

@@ -0,0 +1,54 @@
+from collections.abc import Iterable
+from pathlib import Path
+
+from InquirerPy.base.control import Choice
+from InquirerPy.separator import Separator
+
+from umu_commander import database as db
+from umu_commander.Types import Element
+
+
+def count_users(proton_dir: Path, proton_ver: Path) -> str:
+    return (
+        f"({len(db.get(proton_dir, proton_ver))})"
+        if proton_ver in db.get(proton_dir)
+        else "(-)"
+    )
+
+
+def build_choices(
+    elements: Iterable[Path | Element] | None,
+    groups: dict[Path | Element, Iterable[Path | Element]] | None,
+    *,
+    count_elements: bool = False,
+) -> list[Separator | Choice | str]:
+    if elements is None:
+        elements = []
+
+    if groups is None:
+        groups = {}
+
+    choices: list[Choice | Separator] = [Choice(el, name=el.name) for el in elements]
+    if len(choices) > 0:
+        choices.append(Separator(""))
+
+    for group, elements in groups.items():
+        choices.extend(
+            [
+                Separator(f"In: {group}"),
+                *[
+                    Choice(
+                        el,
+                        name=(
+                            el.name
+                            if not count_elements
+                            else f"{el.name} {count_users(group, el)}"
+                        ),
+                    )
+                    for el in elements
+                ],
+                Separator(""),
+            ]
+        )
+
+    return choices

umu_commander-2.0.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: umu-commander
+Version: 2.0.0
+Summary: umu-commander is an interactive CLI tool to help you manage umu.
+Project-URL: Homepage, https://github.com/Mpaxlamitsounas/umu-commander
+Project-URL: Issues, https://github.com/Mpaxlamitsounas/umu-commander/issues
+Author-email: Mpaxlamitsounas <mpaxlamitsounas@mailbox.org>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: umu,umu-launcher
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Requires-Dist: inquirerpy
+Requires-Dist: tomli-w
+Description-Content-Type: text/markdown
+
+## umu-commander
+### umu-commander is a CLI tool to augment umu-launcher as well as help you manage its Proton versions.
+
+This tool does not provide a centralised way of managing your games or utilise template umu-configs. See [faugus-launcher](https://github.com/Faugus/faugus-launcher) or [Nero-umu](https://github.com/SeongGino/Nero-umu) for something more akin to a games launcher, and [umu-wrapper](https://github.com/korewaChino/umu-wrapper) for templating functionality. 
+
+Proton versions can track and untrack directories, with the intention of safely removing them once no game depends on one.
+
+Vanilla umu config files currently (06/2025) do not support setting environmental variables. This tool adds such functionality with an extra TOML table within said configs, see `example_config.toml` for an example.
+
+### Config
+The configuration file lives at `~/.config/umu-commander.toml`, which cannot be changed as of now. You can generate one by running the app by itself.
+
+The config schema is as follows:
+
+| Name                       | Description                                                        |
+|:---------------------------|:-------------------------------------------------------------------|
+| `DB_DIR`                   | Directory where the Tracking DB is stored.                         |
+| `DB_NAME`                  | Tracking DB filename.                                              |
+| `DEFAULT_PREFIX_DIR`       | Directory where umu-commander will search for WINE prefixes.       |
+| `PROTON_PATHS`             | List of directories umu-commander will search for Proton versions. |
+| `UMU_CONFIG_NAME`          | Name of the umu config created using umu-commander create.         |
+| `UMU_PROTON_PATH`          | Directory where umu-launcher downloads its UMU-Proton versions.    |
+| `[DLL_OVERRIDES_OPTIONS]`  | TOML table where all possible DLL overrides are listed.            |
+| `[LANG_OVERRIDES_OPTIONS]` | TOML table where all possible LANG overrides are listed.           |
+
+To add an extra DLL override option, add a line below the table in the form "`Label`" = "`WINE DLL override string`". Use the winhttp example as an example. You can add LANG overrides in a similar way.
+
+### Verbs
+umu-commander needs one of the following verbs specified after the executable name:
+
+| Name      | Description                                                                                                                                                                                                                                                                  |
+|:----------|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `track`   | Tracks current directory with the selected Proton version.<br/>Also removes it from any other tracking lists.                                                                                                                                                                |
+| `untrack` | Removes the current directory from all tracking lists.                                                                                                                                                                                                                       |
+| `users`   | Lists which directories the selected Proton version is tracking.                                                                                                                                                                                                             |
+| `delete`  | Interactively deletes Proton versions that are currently tracking nothing.<br/>Will not remove the latest UMU-Proton and Proton versions that haven't been used for tracking before.<br/>umu-commander will never delete anything without invoking this verb and confirming. |
+| `create`  | Creates an augmented umu config in the current directory.<br/>These configs are compatible with vanilla umu-launcher, although the DLL override functionality won't work.                                                                                                    |
+| `run`     | Runs a program using the umu config in the current directory.                                                                                                                                                                                                                |
+
+### Installation/Usage
+Add umu-run to your PATH and then install with pipx by running `pipx install umu-commander`. After that you can use umu-commander by running `umu-commander <verb>`. 
+
+### Return codes
+| Number | Name                | Description                                                     |
+|:-------|:--------------------|:----------------------------------------------------------------|
+| 0      | `SUCCESS`           | Program executed as intended.                                   |
+| 1      | `DECODING_ERROR`    | Failed to parse a file.                                         |
+| 2      | `INVALID_SELECTION` | User selected an invalid verb or there are no valid selections. |

umu_commander-2.0.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+umu_commander/__init__.py,sha256=-3JbEnHqNK10K0pGrhFCFjxwXzBjLE5T-1MkDxQ9IUc,19
+umu_commander/__main__.py,sha256=ggA7wDkJiQjy4qA3MxgoAOG_cdOVAe8hsAyWth8bzEI,5752
+umu_commander/configuration.py,sha256=wUvUNloJ17sZ8bRt1NmNQLyV83nnKE_sQ8hxmOLa7kw,2968
+umu_commander/database.py,sha256=Ix5ISzUKWF0xs3BUfhB8-azmKiWgP3NiaviKMydI-0E,1890
+umu_commander/proton.py,sha256=ZYew3Yn4m02tY0Y13E6loMSdxRSOIHA4t-1_BnxZa4g,1962
+umu_commander/tracking.py,sha256=l7bmedS-Z0d1oBrfpqx6bN2Ywged6gWwmSgzNyhXy0I,3837
+umu_commander/umu_config.py,sha256=iM3Dkx3wFlLtw4y86BHnA5vAZjPzgD7Ah7VevMz1w8s,5620
+umu_commander/util.py,sha256=xd9oF2sP49m7z1dFtvhD8NeAI2-_i1eX0aLcm8ttd4o,1450
+umu_commander/Types/__init__.py,sha256=oDPHddB3i2Loo5eGg947USr6L0qGvMoS5TBo-3OR1dk,369
+umu_commander-2.0.0.dist-info/METADATA,sha256=006spJJU2jDMLKNNjDtWljx3U5tjauXIYeio6eyg0z8,5924
+umu_commander-2.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+umu_commander-2.0.0.dist-info/entry_points.txt,sha256=ljyUmDmgCCMm7mQgB1syoWbf_5AiemyrS6YN7eTn9CI,62
+umu_commander-2.0.0.dist-info/licenses/LICENSE.txt,sha256=yipFXBRmVZ2Q44x1q18HccPUAECBQLXAOAr21aS57uY,1071
+umu_commander-2.0.0.dist-info/RECORD,,

umu_commander-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

umu_commander-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+umu-commander = umu_commander.__main__:main

umu_commander-2.0.0.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 mpaxlamitsounas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.