umu-commander 1.4.0__py3-none-any.whl

umu_commander/classes.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+
+
+# analogous to Proton version
+@dataclass
+class Element:
+    group_id: str = ""
+    value: str = ""
+    info: str = ""
+
+    # proton terminology for convenience
+    @property
+    def dir(self):
+        return self.group_id
+
+    @property
+    def version_num(self):
+        return self.value
+
+    @property
+    def user_count(self):
+        return self.info
+
+    @user_count.setter
+    def user_count(self, value):
+        self.info = value
+
+
+# analogous to Proton directory
+@dataclass
+class Group:
+    identity: str = ""
+    label: str = ""
+    elements: list[Element] = list
+
+    # proton terminology for convenience
+    @property
+    def path(self):
+        return self.identity
+
+    @property
+    def versions(self):
+        return self.elements

umu_commander/configuration.py

@@ -0,0 +1,22 @@
+import os
+from pathlib import Path
+
+from umu_commander.classes import Element
+
+PROTON_DIRS: list[str] = [
+    os.path.join(Path.home(), ".local/share/Steam/compatibilitytools.d/"),
+    os.path.join(Path.home(), ".local/share/umu/compatibilitytools"),
+]
+# where UMU saves its UMU-Proton versions
+UMU_PROTON_DIR: str = os.path.join(
+    Path.home(), ".local/share/Steam/compatibilitytools.d/"
+)
+DB_NAME: str = "tracking.json"
+DB_DIR: str = os.path.join(Path.home(), ".local/share/umu/compatibilitytools")
+CONFIG_NAME: str = "umu-config.toml"
+# default WINE prefix directory
+PREFIX_DIR: str = os.path.join(Path.home(), ".local/share/wineprefixes/")
+# Label, override string, follow the example
+DLL_OVERRIDES_OPTIONS: list[Element] = [
+    Element(info="winhttp for BepInEx", value="winhttp.dll=n;")
+]

umu_commander/db.py

@@ -0,0 +1,66 @@
+import json
+from collections import defaultdict
+from json import JSONDecodeError
+
+from umu_commander.configuration import *
+
+_db: defaultdict[str, defaultdict[str, list[str]]]
+
+
+def load():
+    global _db
+
+    if not os.path.exists(DB_DIR):
+        os.mkdir(DB_DIR)
+
+    try:
+        with open(os.path.join(DB_DIR, DB_NAME), "rt") as db_file:
+            _db = defaultdict(lambda: defaultdict(list))
+            _db.update(json.load(db_file))
+
+    except JSONDecodeError:
+        print(f"Could not decode DB file, is it valid JSON?")
+        raise JSONDecodeError("", "", 0)
+
+    except FileNotFoundError:
+        _db = defaultdict(lambda: defaultdict(list))
+
+
+def dump():
+    with open(os.path.join(DB_DIR, DB_NAME), "wt") as db_file:
+        # noinspection PyTypeChecker
+        json.dump(_db, db_file, indent="\t")
+
+
+def copy():
+    return _db.copy()
+
+
+def get(proton_dir: str, proton_ver: str = None) -> dict[str, list[str]] | list[str]:
+    if proton_ver is None:
+        return _db[proton_dir]
+
+    return _db[proton_dir][proton_ver]
+
+
+# add user_dir to proton_ver's of proton_dir list of users
+def add_to(proton_dir: str, proton_ver: str, user_dir: str):
+    global _db
+
+    if proton_ver not in _db[proton_dir]:
+        _db[proton_dir][proton_ver] = []
+
+    _db[proton_dir][proton_ver].append(user_dir)
+
+
+def remove_from(proton_dir: str, proton_ver: str, user_dir: str):
+    global _db
+
+    if user_dir in _db[proton_dir][proton_ver]:
+        _db[proton_dir][proton_ver].remove(user_dir)
+
+
+def delete(proton_dir: str, proton_ver: str):
+    global _db
+
+    del _db[proton_dir][proton_ver]

umu_commander/main.py

@@ -0,0 +1,55 @@
+#!/usr/bin/python3
+import sys
+from json import JSONDecodeError
+
+from umu_commander import db, tracking, umu_config
+from umu_commander.configuration import *
+
+
+def print_help():
+    print(
+        "umu-commander is an interactive CLI tool to help you manage Proton versions used by umu, as well as create enhanced launch configs.",
+        "",
+        "For details, explanations, and more, see the README.md file, or visit https://github.com/Mpaxlamitsounas/umu-commander.",
+        sep="\n",
+    )
+
+
+def main() -> int:
+    try:
+        db.load()
+    except JSONDecodeError:
+        print(f"Tracking file at {os.path.join(DB_DIR, DB_NAME)} could not be read.")
+        return 2
+
+    if len(sys.argv) == 1:
+        print_help()
+        return 0
+
+    verb: str = sys.argv[1]
+    match verb:
+        case "track":
+            tracking.track()
+        case "untrack":
+            tracking.untrack()
+        case "users":
+            tracking.users()
+        case "delete":
+            tracking.delete()
+        case "create":
+            umu_config.create()
+        case "run":
+            umu_config.run()
+        case _:
+            print("Invalid verb.")
+            print_help()
+            return 3
+
+    tracking.untrack_unlinked()
+    db.dump()
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

umu_commander/proton.py

@@ -0,0 +1,66 @@
+import os
+import re
+import subprocess
+
+from umu_commander.classes import Element, Group
+from umu_commander.configuration import DB_NAME, PROTON_DIRS, UMU_PROTON_DIR
+
+
+def _natural_sort_proton_ver_key(e: Element, _nsre=re.compile(r"(\d+)")):
+    s: str = e.value
+    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"Using {line[left:len(line) - 1]}.")
+            except ValueError:
+                print("Could not fetch latest UMU-Proton.")
+
+            break
+
+
+def _sort_proton_versions(versions: list[Element]) -> list[Element]:
+    return sorted(versions, key=_natural_sort_proton_ver_key, reverse=True)
+
+
+def collect_proton_versions(sort: bool = False) -> list[Group]:
+    version_groups: list[Group] = []
+    for proton_dir in PROTON_DIRS:
+        versions: list[Element] = [
+            Element(proton_dir, version, "")
+            for version in os.listdir(proton_dir)
+            if version != DB_NAME
+        ]
+        if sort:
+            versions = sorted(versions, key=_natural_sort_proton_ver_key, reverse=True)
+
+        version_groups.append(
+            Group(proton_dir, f"Proton versions in {proton_dir}:", versions)
+        )
+
+    return version_groups
+
+
+def get_latest_umu_proton():
+    umu_proton_versions: list[Element] = [
+        Element(UMU_PROTON_DIR, version, "")
+        for version in os.listdir(UMU_PROTON_DIR)
+        if "UMU" in version and version != DB_NAME
+    ]
+    umu_proton_versions = sorted(
+        umu_proton_versions, key=_natural_sort_proton_ver_key, reverse=True
+    )
+
+    return umu_proton_versions[0].version_num

umu_commander/tracking.py

@@ -0,0 +1,97 @@
+import shutil
+
+from umu_commander import db
+from umu_commander.classes import Group
+from umu_commander.configuration import *
+from umu_commander.proton import (
+    collect_proton_versions,
+    get_latest_umu_proton,
+    refresh_proton_versions,
+)
+from umu_commander.util import (
+    get_selection,
+)
+
+
+def untrack(quiet: bool = False):
+    current_dir: str = os.getcwd()
+    for proton_dir in db.copy().keys():
+        for proton_ver in db.get(proton_dir):
+            db.remove_from(proton_dir, proton_ver, current_dir)
+
+    if not quiet:
+        print("Directory removed from all user lists.")
+
+
+def track(proton: Element = None, refresh_versions: bool = True, quiet: bool = False):
+    if refresh_versions:
+        refresh_proton_versions()
+
+    if proton is None:
+        proton: Element = get_selection(
+            "Select Proton version to add directory as user:",
+            None,
+            collect_proton_versions(sort=True),
+        )
+
+    untrack(quiet=True)
+    current_directory: str = os.getcwd()
+    db.add_to(proton.dir, proton.version_num, current_directory)
+
+    if not quiet:
+        print(
+            f"Directory {current_directory} added to Proton version's {proton.version_num} in {proton.dir} user list."
+        )
+
+
+def users():
+    proton_version_dirs: list[Group] = collect_proton_versions(sort=True)
+
+    for proton_dir in proton_version_dirs:
+        for proton in proton_dir.versions:
+            if proton.version_num in db.get(proton.dir):
+                proton.user_count = (
+                    "(" + str(len(db.get(proton.dir, proton.version_num))) + ")"
+                )
+            else:
+                proton.user_count = "(-)"
+
+    proton: Element = get_selection(
+        "Select Proton version to view user list:", None, proton_version_dirs
+    )
+
+    if proton.dir in db.copy() and proton.version_num in db.get(proton.dir):
+        version_users: list[str] = db.get(proton.dir, proton.version_num)
+        if len(version_users) > 0:
+            print(f"Directories using {proton.version_num} of {proton.dir}:")
+            print(*version_users, sep="\n")
+        else:
+            print("No directories currently use this version.")
+    else:
+        print("This version hasn't been used by umu before.")
+
+
+def delete():
+    for proton_dir in db.copy().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:
+                selection: str = input(
+                    f"{proton_ver} in {proton_dir} has no using directories, delete? (Y/N) ? "
+                )
+                if selection.lower() == "y":
+                    try:
+                        shutil.rmtree(os.path.join(proton_dir, proton_ver))
+                    except FileNotFoundError:
+                        pass
+                    db.delete(proton_dir, proton_ver)
+
+
+def untrack_unlinked():
+    for proton_dir in db.copy().keys():
+        for proton_ver, version_users in db.get(proton_dir).items():
+            for user in version_users:
+                if not os.path.exists(user):
+                    db.remove_from(proton_dir, proton_ver, user)

umu_commander/umu_config.py

@@ -0,0 +1,147 @@
+import subprocess
+import tomllib
+from collections.abc import Mapping
+from typing import Any
+
+from umu_commander import tracking
+from umu_commander.configuration import *
+from umu_commander.proton import collect_proton_versions, refresh_proton_versions
+from umu_commander.util import (
+    get_selection,
+    values_to_elements,
+)
+
+
+def _write(params: Mapping[str, Any]):
+    config: str = "[umu]\n"
+    for key in set(params.keys()) - {"env", "launch_args"}:
+        config += f'{key} = "{params[key]}"\n'
+
+    config += f"launch_args = {params["launch_args"]}\n"
+
+    config += "\n[env]\n"
+    for key, value in params["env"].items():
+        config += f'{key} = "{value}"\n'
+
+    config_file = open(CONFIG_NAME, "wt")
+    config_file.write(config)
+    config_file.close()
+
+
+def create():
+    refresh_proton_versions()
+
+    params: dict[str, Any] = {"env": {}}
+
+    # Prefix selection
+    selection: str = get_selection(
+        "Select wine prefix:",
+        values_to_elements([*os.listdir(PREFIX_DIR), "Current directory"]),
+        None,
+    ).value
+
+    if selection == "Current directory":
+        params["prefix"] = os.path.join(os.getcwd(), "prefix")
+    else:
+        params["prefix"] = os.path.join(PREFIX_DIR, selection)
+
+    # Proton selection
+    selected_umu_latest: bool = False
+    proton: Element = get_selection(
+        "Select Proton version:",
+        values_to_elements(["Always latest UMU Proton"]),
+        [*collect_proton_versions(sort=True)],
+    )
+    if proton.value == "Always latest UMU Proton":
+        selected_umu_latest = True
+    else:
+        params["proton"] = os.path.join(proton.dir, proton.version_num)
+
+    # Select DLL overrides
+    possible_overrides: list[Element] = [
+        Element(info="Reset"),
+        Element(info="Done"),
+        *DLL_OVERRIDES_OPTIONS,
+    ]
+    selected: set[int] = set()
+    while True:
+        print("Select DLLs to override, you can select multiple:")
+        for idx, override in enumerate(possible_overrides):
+            if idx in selected:
+                idx = "Y"
+            print(f"{idx}) {override.info}")
+
+        try:
+            index: int = int(input("? "))
+            print("")
+        except ValueError:
+            continue
+
+        if index == 0:
+            selected = set()
+            continue
+
+        if index == 1:
+            break
+
+        index: int = int(index)
+        if index - 1 < len(possible_overrides):
+            selected.add(index)
+
+    if len(selected) > 0:
+        params["env"]["WINEDLLOVERRIDES"] = ""
+        for selection in selected:
+            # noinspection PyTypeChecker
+            params["env"]["WINEDLLOVERRIDES"] += possible_overrides[selection].value
+
+    # Set language locale
+    match get_selection(
+        "Select locale:",
+        values_to_elements(["Default", "Japanese"]),
+        None,
+    ).value:
+        case "Default":
+            pass
+        case "Japanese":
+            params["env"]["LANG"] = "ja_JP.UTF8"
+
+    # Input executable launch args
+    launch_args: list[str] = input(
+        "Enter executable options, separated by spaces:\n? "
+    ).split()
+    params["launch_args"] = launch_args
+
+    # Select executable name
+    files: list[str] = [
+        file
+        for file in os.listdir(os.getcwd())
+        if os.path.isfile(os.path.join(os.getcwd(), file))
+    ]
+    executable_name: str = get_selection(
+        "Select game executable:", values_to_elements(files), None
+    ).value
+    params["exe"] = executable_name
+
+    try:
+        _write(params)
+        print(f"Configuration file {CONFIG_NAME} created at {os.getcwd()}.")
+        print(f"Use by running umu-commander run.")
+        if not selected_umu_latest:
+            tracking.track(proton, False)
+    except:
+        print("Could not create configuration file.")
+
+
+def run():
+    with open(CONFIG_NAME, "rb") as toml_file:
+        # noinspection PyTypeChecker
+        config = tomllib.load(toml_file)
+
+        if not os.path.exists(config["umu"]["prefix"]):
+            os.mkdir(config["umu"]["prefix"])
+
+        os.environ.update(config.get("env", {}))
+        subprocess.run(
+            args=["umu-run", "--config", CONFIG_NAME],
+            env=os.environ,
+        )

umu_commander/util.py

@@ -0,0 +1,94 @@
+from umu_commander.classes import Group
+from umu_commander.configuration import *
+
+
+def values_to_elements(values: list[str]) -> list[Element]:
+    return [Element(value=value) for value in values]
+
+
+def _selection_set_valid(
+    selection_elements: list[Element] | None, selection_groups: list[Group] | None
+):
+    if (selection_elements is None or len(selection_elements) == 0) and (
+        len(selection_groups) == 0
+        or all([len(group.elements) == 0 for group in selection_groups])
+    ):
+        return False
+    else:
+        return True
+
+
+def _print_selection_group(
+    elements: list[Element], enum_start_idx: int, tab: bool = True
+):
+    prefix: str = "\t" if tab else ""
+    print(
+        *[
+            f"{prefix}{idx}) {element.value} {element.info}"
+            for idx, element in enumerate(elements, start=enum_start_idx)
+        ],
+        sep="\n",
+    )
+    print("")
+
+
+def _translate_index_to_selection(
+    selection_index: int,
+    selection_elements: list[Element],
+    selection_groups: list[Group],
+) -> Element:
+    len_counter: int = 0
+
+    if selection_elements is not None:
+        selection_groups.insert(0, Group(elements=selection_elements))
+
+    for group in selection_groups:
+        len_counter += len(group.elements)
+        if len_counter > selection_index:
+            break
+
+    return Element(
+        group.identity, group.elements[selection_index - len_counter].value, ""
+    )
+
+
+def get_selection(
+    prompt: str,
+    selection_elements: list[Element] | None,
+    selection_groups: list[Group] | None,
+) -> Element:
+    if not _selection_set_valid(selection_elements, selection_groups):
+        print("Nothing to select from.")
+        exit(4)
+
+    if selection_groups is None:
+        selection_groups = []
+
+    while True:
+        enum_start_idx: int = 1
+
+        print(prompt)
+
+        if selection_elements is not None:
+            _print_selection_group(selection_elements, enum_start_idx, tab=False)
+            enum_start_idx += len(selection_elements)
+
+        for group_idx, group in enumerate(selection_groups):
+            if len(group.elements) == 0:
+                continue
+
+            print(group.label)
+            _print_selection_group(group.elements, enum_start_idx)
+
+            enum_start_idx += len(group.elements)
+
+        selection_index: str = input("? ")
+        print("")
+        if selection_index.isdecimal():
+            selection_index: int = int(selection_index) - 1
+            if enum_start_idx - 1 > selection_index >= 0:
+                break
+
+    return _translate_index_to_selection(
+        selection_index, selection_elements, selection_groups
+    )

umu_commander-1.4.0.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: umu-commander
+Version: 1.4.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 <worldstudy123@gmail.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: umu
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+## umu-commander
+### umu-commander is an interactive CLI tool to help you manage Proton versions used by umu, as well as create enhanced launch configs.
+
+Proton versions can be tracked and untracked, with the intention of being safely removable once no game depends on a specific one.\
+What directories each Proton version is being used by is tracked within `tracking.json` inside your umu Proton directory by default.
+
+Vanilla umu configuration files currently do not support setting environmental variables, this tool adds such functionality by adding an extra TOML table in the umu config itself. An example config is available under the name `example_config.toml`.
+
+umu-commander will look for your installed Proton versions using a predetermined list of directories, if you notice some versions missing, the listed can be edited within the `configuration.py` file in the src directory.
+
+### Verbs
+umu-commander needs one of the following verbs specified after the executable name:
+* track: Adds the current directory to a specified Proton version's list of users.
+  * If the directory is already in another list, it will be removed from it.
+  * The create verb will automatically track the current directory.
+  * This will not update any existing configs.
+* untrack:  Removes the current directory from all tracking lists.
+* users: Lists each Proton version's users.
+* delete: Interactively deletes any Proton version in the tracking database with no users.
+  * This will actually remove the Proton directories, use at your own risk.
+  * If a Proton version has not been tracked before, it will not be removed, neither will the latest umu Proton.
+  * umu-commander will not delete anything without invoking this verb and receiving confirmation.
+* create: Creates a custom configuration file in the current directory.
+* run: Uses the config in the current directory to run the program.
+  * This is NOT equivalent to `umu-run --config <config_name>`, as vanilla umu configs do not support setting environment variables as of 07/2025.
+  
+### Installation/Usage
+Add umu-run to your PATH and then install with pipx by running `pipx install umu-commander`. After that you can invoke umu-commander by running `umu-commander <verb>`. 

umu_commander-1.4.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+umu_commander/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+umu_commander/classes.py,sha256=-_5vgcWIwQ3btE8yVc1v8sbBKH9iAR_qqO0XogtqhK8,784
+umu_commander/configuration.py,sha256=EOlXyB5xs2befhNdmUzlgWzZqUVAuOhfAEp3P7DCcPc,798
+umu_commander/db.py,sha256=T_Rw2WbPi3Ig4kS1xUhfeLeH0IXm7ZIFwx_KOsrvij8,1596
+umu_commander/main.py,sha256=CW8GopWCOLzWMS8_43RihRmjm_4yu0IXVGiMC7yap2k,1306
+umu_commander/proton.py,sha256=KrkrBcNlRNpfwtAloUQQbThw6ioWiDgtQCqqlHYEQRg,2031
+umu_commander/tracking.py,sha256=NdRarb_r65pDZXZer9Ls4uWqYhEd48qODp9hF68xpEQ,3219
+umu_commander/umu_config.py,sha256=jBpIvf55QmolgHX43XM5Lmg_xUbL13zCLZMjqdAGalE,4189
+umu_commander/util.py,sha256=f5YaYvyug4Tv8ydkhFy-AwEgWtVycV9-576A7h1D-dg,2644
+umu_commander-1.4.0.dist-info/METADATA,sha256=r7MWhMvSQwoXcoB_2ukpOtZ5uF3gHljvJ88dc7xNF-c,2791
+umu_commander-1.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+umu_commander-1.4.0.dist-info/entry_points.txt,sha256=7RGP35zAHeEojZ-sv7JIITuMeH_VVNuG2g2_SUrUnbM,58
+umu_commander-1.4.0.dist-info/licenses/LICENSE.txt,sha256=yipFXBRmVZ2Q44x1q18HccPUAECBQLXAOAr21aS57uY,1071
+umu_commander-1.4.0.dist-info/RECORD,,

umu_commander-1.4.0.dist-info/WHEEL

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

umu_commander-1.4.0.dist-info/entry_points.txt

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

umu_commander-1.4.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.