umu-commander 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

umu_commander/__init__.py

@@ -1 +1 @@
-VERSION = "v1.6.2"
+VERSION = "v1.7.0"

umu_commander/__main__.py

@@ -1,7 +1,8 @@
-import os
 import sys
-from collections.abc import Callable
 from json import JSONDecodeError
+from pathlib import Path
+
+from InquirerPy.exceptions import InvalidArgument
 
 from umu_commander import configuration as config
 from umu_commander import database as db
@@ -10,27 +11,22 @@ from umu_commander.classes import ExitCode
 from umu_commander.configuration import CONFIG_DIR, CONFIG_NAME
 from umu_commander.util import print_help
 
-# TODO: Add related projects shoutout
-# https://github.com/Faugus/faugus-launcher
-# https://github.com/SeongGino/Nero-umu
-# https://github.com/korewaChino/umu-wrapper
-
-# TODO: https://inquirerpy.readthedocs.io/en/latest/
-
 
-def main() -> ExitCode:
+def init() -> ExitCode:
     try:
         config.load()
 
     except (JSONDecodeError, KeyError):
-        config_path: str = os.path.join(CONFIG_DIR, CONFIG_NAME)
-        config_path_old: str = os.path.join(CONFIG_DIR, CONFIG_NAME + ".old")
+        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 os.path.exists(config_path_old):
+        if not config_path_old.exists():
             print(f"Config file renamed to {config_path_old}.")
-            os.rename(config_path, config_path_old)
+            config_path.rename(config_path_old)
+
+        return ExitCode.DECODING_ERROR
 
     except FileNotFoundError:
         config.dump()
@@ -39,51 +35,59 @@ def main() -> ExitCode:
         db.load()
 
     except JSONDecodeError:
-        db_path: str = os.path.join(config.DB_DIR, config.DB_NAME)
-        db_path_old: str = os.path.join(config.DB_DIR, config.DB_NAME + ".old")
+        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 os.path.exists(db_path_old):
+        if not db_path_old.exists():
+            db_path.rename(db_path_old)
             print(f"DB file renamed to {db_path_old}.")
-            os.rename(db_path, db_path_old)
 
     except FileNotFoundError:
         pass
 
-    dispatch: dict[str, Callable] = {
-        "track": tracking.track,
-        "untrack": tracking.untrack,
-        "users": tracking.users,
-        "delete": tracking.delete,
-        "create": umu_config.create,
-        "run": umu_config.run,
-    }
+    return ExitCode.SUCCESS
+
+
+def main() -> int:
+    if (return_code := init()) != ExitCode.SUCCESS:
+        return return_code.value
 
     try:
-        dispatch[sys.argv[1]]()
+        match sys.argv[1]:
+            case "track":
+                tracking.track(),
+            case "untrack":
+                tracking.untrack(),
+            case "users":
+                tracking.users(),
+            case "delete":
+                tracking.delete(),
+            case "create":
+                umu_config.create({"umu": {}, "env": {}}, True),
+            case "run":
+                umu_config.run(),
+            case _:
+                print("Unrecognised verb.")
+                print_help()
+                return ExitCode.INVALID_SELECTION.value
 
     except IndexError:
         print_help()
-        return_val = ExitCode.SUCCESS
-
-    except KeyError:
-        print("Unrecognised verb.")
-        print_help()
-        return_val = ExitCode.INVALID_SELECTION
+        return ExitCode.SUCCESS.value
 
-    except ValueError:
-        return_val = ExitCode.INVALID_SELECTION
+    except InvalidArgument:
+        print("No choices to select from.")
+        return ExitCode.INVALID_SELECTION.value
 
     else:
-        return_val = ExitCode.SUCCESS
+        return ExitCode.SUCCESS.value
 
     finally:
         tracking.untrack_unlinked()
         db.dump()
 
-    return return_val.value
-
 
 if __name__ == "__main__":
     exit(main())

umu_commander/classes.py

@@ -1,78 +1,15 @@
-from dataclasses import dataclass
 from enum import Enum
 
 
-@dataclass
-class Element:
-    group_id: str = ""
-    value: str = ""
-    info: str = ""
+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
 
-    def as_proton_ver(self) -> "ProtonVer":
-        return ProtonVer(self.group_id, self.value, self.info)
-
-    def as_dll_override(self) -> "DLLOverride":
-        return DLLOverride(self.info, self.value)
-
-
-@dataclass
-class ProtonVer(Element):
-    def __init__(self, dir: str = "", version_num: str = "", user_count: str = ""):
-        super().__init__(group_id=dir, value=version_num, info=user_count)
-
-    @property
-    def dir(self):
-        return self.group_id
-
-    @property
-    def version_num(self):
-        return self.value
-
-    @property
-    def user_count(self):
-        return self.info
-
-
-@dataclass
-class DLLOverride(Element):
-    def __init__(self, label: str = "", override_str: str = ""):
-        super().__init__(group_id="", value=override_str, info=label)
-
-    @property
-    def override_str(self):
-        return self.value
-
-    @property
-    def label(self):
-        return self.info
-
-
-@dataclass
-class Value(Element):
-    def __init__(self, value: str):
-        super().__init__(value=value)
-
-
-@dataclass
-class Group:
-    identity: str = ""
-    label: str = ""
-    elements: list[Element] = list
-
-
-@dataclass
-class ProtonDir(Group):
-    @property
-    def path(self):
-        return self.identity
-
-    @property
-    def versions(self) -> list[ProtonVer]:
-        return [e.as_proton_ver() for e in self.elements]
-
-    @versions.setter
-    def versions(self, value):
-        self.elements = value
+        return instance
 
 
 class ExitCode(Enum):

umu_commander/configuration.py

@@ -6,48 +6,59 @@ from typing import Any
 
 import tomli_w
 
-from umu_commander.classes import DLLOverride
+from umu_commander.classes import Element
 
-CONFIG_DIR: str = os.path.join(Path.home(), ".config")
-CONFIG_NAME: str = "umu-commander.toml"
+CONFIG_DIR: Path = Path.home() / ".config"
+CONFIG_NAME: Path = Path("umu-commander.toml")
 
 
-PROTON_PATHS: tuple[str, ...] = (
-    os.path.join(Path.home(), ".local/share/Steam/compatibilitytools.d/"),
-    os.path.join(Path.home(), ".local/share/umu/compatibilitytools"),
+PROTON_PATHS: tuple[Path, ...] = (
+    Path.home() / ".local/share/Steam/compatibilitytools.d/",
+    Path.home() / ".local/share/umu/compatibilitytools",
 )
-UMU_PROTON_PATH: 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")
-UMU_CONFIG_NAME: str = "umu-config.toml"
-DEFAULT_PREFIX_DIR: str = os.path.join(Path.home(), ".local/share/wineprefixes/")
-DLL_OVERRIDES_OPTIONS: tuple[DLLOverride, ...] = (
-    DLLOverride("winhttp for BepInEx", "winhttp.dll=n;"),
+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"
+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)
-        if "DLL_OVERRIDES_OPTIONS" in toml_conf:
-            toml_conf["DLL_OVERRIDES_OPTIONS"] = tuple(
-                [
-                    DLLOverride(label, override_str)
-                    for label, override_str in toml_conf[
-                        "DLL_OVERRIDES_OPTIONS"
-                    ].items()
-                ]
+
+        # 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"]
 
-        module = importlib.import_module(__name__)
         for key, value in toml_conf.items():
-            setattr(module, key, value)
+            setattr(module, key, Path(value))
 
 
 def _get_attributes() -> dict[str, Any]:
-    module = importlib.import_module(__name__)
     attributes: dict[str, Any] = {}
     for key in dir(module):
         value = getattr(module, key)
@@ -66,8 +77,17 @@ def dump():
         del toml_conf["CONFIG_DIR"]
         del toml_conf["CONFIG_NAME"]
 
-        toml_conf["DLL_OVERRIDES_OPTIONS"] = dict(
-            [(override.info, override.value) for override in DLL_OVERRIDES_OPTIONS]
-        )
+        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

@@ -1,10 +1,10 @@
 import json
-import os
 from collections import defaultdict
+from pathlib import Path
 
 import umu_commander.configuration as config
 
-_db: defaultdict[str, defaultdict[str, list[str]]] = defaultdict(
+_db: defaultdict[Path, defaultdict[Path, list[Path]]] = defaultdict(
     lambda: defaultdict(list)
 )
 
@@ -12,27 +12,41 @@ _db: defaultdict[str, defaultdict[str, list[str]]] = defaultdict(
 def load():
     global _db
 
-    if not os.path.exists(config.DB_DIR):
-        os.mkdir(config.DB_DIR)
-
-    with open(
-        os.path.join(os.path.join(config.DB_DIR, config.DB_NAME)), "rt"
-    ) as db_file:
-        _db.update(json.load(db_file))
+    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 os.path.exists(config.DB_DIR):
-        os.mkdir(config.DB_DIR)
-
-    with open(os.path.join(config.DB_DIR, config.DB_NAME), "wt") as db_file:
+    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")
+        json.dump(db, db_file, indent="\t")
 
 
 def get(
-    proton_dir: str = None, proton_ver: str = None
-) -> dict[str, dict[str, list[str]]] | dict[str, list[str]] | list[str]:
+    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:

umu_commander/proton.py

@@ -1,14 +1,13 @@
-import os
 import re
 import subprocess
+from collections.abc import Iterable
+from pathlib import Path
 
 import umu_commander.configuration as config
-import umu_commander.database as db
-from umu_commander.classes import ProtonDir, ProtonVer
 
 
-def _natural_sort_proton_ver_key(p: ProtonVer, _nsre=re.compile(r"(\d+)")):
-    s: str = p.version_num
+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)]
 
 
@@ -32,51 +31,35 @@ def refresh_proton_versions():
             break
 
 
-def _sort_proton_versions(versions: list[ProtonVer]) -> list[ProtonVer]:
-    return sorted(versions, key=_natural_sort_proton_ver_key, reverse=True)
-
-
-def collect_proton_versions(
-    sort: bool = False, user_count: bool = False
-) -> list[ProtonDir]:
-    def get_user_count(proton_dir: str, proton_ver) -> str:
-        return (
-            "(" + str(len(db.get(proton_dir, proton_ver))) + ")"
-            if proton_ver in db.get(proton_dir)
-            else "(-)"
-        )
-
-    proton_dirs: list[ProtonDir] = []
+def collect_proton_versions(sort: bool = False) -> dict[Path, Iterable[Path]]:
+    versions: dict[Path, Iterable[Path]] = {}
     for proton_dir in config.PROTON_PATHS:
-        versions: list[ProtonVer] = [
-            ProtonVer(
-                proton_dir,
-                version,
-                get_user_count(proton_dir, version) if user_count else "",
-            )
-            for version in os.listdir(proton_dir)
-            if os.path.isdir(os.path.join(proton_dir, version))
-        ]
+        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 = sorted(versions, key=_natural_sort_proton_ver_key, reverse=True)
-
-        proton_dirs.append(
-            ProtonDir(proton_dir, f"Proton versions in {proton_dir}:", versions)
-        )
+            versions[proton_dir] = sorted(
+                versions[proton_dir], key=_natural_sort_proton_ver_key, reverse=True
+            )
 
-    return proton_dirs
+    return versions
 
 
-def get_latest_umu_proton():
-    umu_proton_versions: list[ProtonVer] = [
-        ProtonVer(config.UMU_PROTON_PATH, version)
-        for version in os.listdir(config.UMU_PROTON_PATH)
-        if "UMU" in version
-        and os.path.isdir(os.path.join(config.UMU_PROTON_PATH, version))
+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].version_num
+    return umu_proton_versions[0]

umu_commander/tracking.py

@@ -1,64 +1,74 @@
-import os
 import shutil
+from pathlib import Path
+
+from InquirerPy import inquirer
 
 import umu_commander.database as db
-from umu_commander.classes import ProtonDir, ProtonVer
 from umu_commander.proton import (
     collect_proton_versions,
     get_latest_umu_proton,
     refresh_proton_versions,
 )
 from umu_commander.util import (
-    get_selection,
+    build_choices,
 )
 
 
-def untrack(quiet: bool = False):
-    current_dir: str = os.getcwd()
+def untrack(target_dir: Path = None, *, quiet: bool = False):
+    if target_dir is None:
+        target_dir = Path.cwd()
+
     for proton_dir in db.get().keys():
         for proton_ver in db.get(proton_dir):
-            if current_dir in db.get(proton_dir, proton_ver):
-                db.get(proton_dir, proton_ver).remove(current_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: ProtonVer = None, refresh_versions: bool = True, quiet: bool = False
+    proton_ver: Path = None,
+    target_dir: Path = None,
+    *,
+    refresh_versions: bool = True,
+    quiet: bool = False,
 ):
-    if refresh_versions:
+    if target_dir is None:
+        target_dir = Path.cwd()
+
+    if refresh_versions and proton_ver is None:
         refresh_proton_versions()
 
     if proton_ver is None:
-        proton_ver: ProtonVer = get_selection(
-            "Select Proton version to track directory with:",
-            None,
-            collect_proton_versions(sort=True),
-        ).as_proton_ver()
+        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()
 
     untrack(quiet=True)
-    current_directory: str = os.getcwd()
-    db.get(proton_ver.dir, proton_ver.version_num).append(current_directory)
+    db.get(proton_ver.parent, proton_ver).append(target_dir)
 
     if not quiet:
         print(
-            f"Directory {current_directory} added to Proton version's {proton_ver.version_num} in {proton_ver.dir} tracking list."
+            f"Directory {target_dir} added to Proton version's {proton_ver.name} in {proton_ver.parent} tracking list."
         )
 
 
-def users():
-    proton_dirs: list[ProtonDir] = collect_proton_versions(sort=True, user_count=True)
-
-    proton_ver: ProtonVer = get_selection(
-        "Select Proton version to view user list:", None, proton_dirs
-    ).as_proton_ver()
-
-    if proton_ver.dir in db.get() and proton_ver.version_num in db.get(proton_ver.dir):
-        version_users: list[str] = db.get(proton_ver.dir, proton_ver.version_num)
+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()
+
+    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.version_num} of {proton_ver.dir}:",
+                f"Directories tracked by {proton_ver.name} of {proton_ver.parent}:",
                 *version_users,
                 sep="\n\t",
             )
@@ -77,12 +87,12 @@ def delete():
                 continue
 
             if len(version_users) == 0:
-                selection: str = input(
-                    f"Version {proton_ver} in {proton_dir} is tracking no directories, delete? (Y/N) ? "
-                )
-                if selection.lower() == "y":
+                confirmed: bool = inquirer.confirm(
+                    f"Version {proton_ver.name} in {proton_dir} is tracking no directories, delete?"
+                ).execute()
+                if confirmed:
                     try:
-                        shutil.rmtree(os.path.join(proton_dir, proton_ver))
+                        shutil.rmtree(proton_dir / proton_ver)
                     except FileNotFoundError:
                         pass
                     del db.get(proton_dir)[proton_ver]
@@ -92,5 +102,5 @@ 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 os.path.exists(user):
+                if not user.exists():
                     db.get(proton_dir, proton_ver).remove(user)

umu_commander/umu_config.py

@@ -1,117 +1,107 @@
 import os
 import subprocess
 import tomllib
+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 tracking
-from umu_commander.classes import DLLOverride, ProtonVer, Value
-from umu_commander.proton import collect_proton_versions, refresh_proton_versions
-from umu_commander.util import get_selection, string_to_value, strings_to_values
+from umu_commander.classes import Element
+from umu_commander.configuration import DLL_OVERRIDES_OPTIONS, LANG_OVERRIDES_OPTIONS
+from umu_commander.proton import (
+    collect_proton_versions,
+    get_latest_umu_proton,
+    refresh_proton_versions,
+)
+from umu_commander.util import build_choices
 
 
-def create():
-    refresh_proton_versions()
+def select_prefix() -> str:
+    default = Element(str(Path.cwd() / "prefix"), "Current directory")
+    choices = build_choices([default, *config.DEFAULT_PREFIX_DIR.iterdir()], None)
+    return str(inquirer.select("Select wine prefix:", choices, default).execute())
 
-    params: dict[str, Any] = {"umu": {}, "env": {}}
 
-    # Prefix selection
-    prefix_default: Value = string_to_value("Current directory")
-    selection: str = get_selection(
-        "Select wine prefix:",
-        [*strings_to_values(os.listdir(config.DEFAULT_PREFIX_DIR)), prefix_default],
-        None,
-        default_element=prefix_default,
-    ).value
-
-    if selection == "Current directory":
-        params["umu"]["prefix"] = os.path.join(os.getcwd(), "prefix")
-    else:
-        params["umu"]["prefix"] = os.path.join(config.DEFAULT_PREFIX_DIR, selection)
+def select_proton() -> str:
+    default = Element(str(get_latest_umu_proton()), "Latest UMU-Proton")
+    choices = build_choices([default], collect_proton_versions(sort=True))
+    return str(
+        inquirer.select(
+            "Select Proton version:", choices, Path.cwd() / "prefix"
+        ).execute()
+    )
 
-    # Proton selection
-    selected_umu_latest: bool = False
-    proton_ver: ProtonVer = get_selection(
-        "Select Proton version:",
-        None,
-        collect_proton_versions(sort=True),
-    ).as_proton_ver()
-    params["umu"]["proton"] = os.path.join(proton_ver.dir, proton_ver.version_num)
 
-    # Select DLL overrides
-    possible_overrides: list[DLLOverride] = [
-        DLLOverride(label="Reset"),
-        DLLOverride(label="Done"),
-        *config.DLL_OVERRIDES_OPTIONS,
-    ]
-    selected: set[int] = set()
-    while True:
-        print("Select DLLs to override, multiple can be selected:")
-        for idx, override in enumerate(possible_overrides):
-            if idx in selected:
-                idx = "Y"
-            print(f"{idx}) {override.label}")
-
-        index: str = input("? ")
-        if index == "":
-            break
-
-        if index.isdecimal():
-            index: int = int(index)
-        else:
-            continue
+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()
+        ]
+    )
 
-        # reset
-        if index == 0:
-            selected = set()
-            continue
 
-        # done
-        if index == 1:
-            break
+def select_lang() -> str:
+    default = Element("", "No override")
+    choices = build_choices([default, *LANG_OVERRIDES_OPTIONS], None)
+    return inquirer.select("Select locale:", choices, default).execute()
 
-        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
-            ].override_str
+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() -> str:
+    files = [file for file in Path.cwd().iterdir() if file.is_file()]
+    choices = build_choices(files, None)
+    return str(inquirer.select("Select game executable:", choices).execute())
+
+
+def create(params: dict[str, dict[str, Any]], interactive: bool):
+    refresh_proton_versions()
+
+    # Prefix selection
+    if params.get("umu").get("prefix") is None:
+        if interactive:
+            params["umu"]["prefix"] = select_prefix()
+        else:
+            params["umu"]["prefix"] = str(Path.cwd() / "prefix")
+
+    # Proton selection
+    if params.get("umu").get("proton") is None:
+        if interactive:
+            params["umu"]["proton"] = select_proton()
+        else:
+            params["umu"]["proton"] = str(get_latest_umu_proton())
+
+    selected_umu_latest: bool = params["umu"]["proton"] == str(get_latest_umu_proton())
+
+    # Select DLL overrides
+    if interactive:
+        params["env"]["WINEDLLOVERRIDES"] = select_dll_override()
+        print(params["env"]["WINEDLLOVERRIDES"])
 
     # Set language locale
-    lang_default: Value = string_to_value("Default")
-    match get_selection(
-        "Select locale:",
-        [lang_default, string_to_value("Japanese")],
-        None,
-        default_element=lang_default,
-    ).value:
-        case "Default":
-            pass
-        case "Japanese":
-            params["env"]["LANG"] = "ja_JP.UTF8"
+    if interactive:
+        if (lang := select_lang()) != "":
+            params["env"]["LANG"] = lang
 
     # Input executable launch args
-    launch_args: list[str] = input(
-        "Enter executable options, separated by spaces:\n? "
-    ).split()
-    params["umu"]["launch_args"] = launch_args
+    if interactive:
+        params["umu"]["launch_args"] = set_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:", strings_to_values(files), None
-    ).value
-    params["umu"]["exe"] = executable_name
+    if params["umu"].get("exe") is None:
+        params["umu"]["exe"] = select_exe()
 
     try:
         with open(config.UMU_CONFIG_NAME, "wb") as file:
@@ -119,21 +109,26 @@ def create():
 
         print(f"Configuration file {config.UMU_CONFIG_NAME} created at {os.getcwd()}.")
         print(f"Use by running umu-commander run.")
-        tracking.track(proton_ver, False)
+        if not selected_umu_latest:
+            tracking.track(
+                Path(params["umu"]["proton"], Path(params["umu"]["exe"])).parent,
+                refresh_versions=False,
+            )
     except:
         print("Could not create configuration file.")
 
 
 def run():
-    if not os.path.exists(config.UMU_CONFIG_NAME):
+    if not config.UMU_CONFIG_NAME.exists():
         print("No umu config in current directory.")
         return
 
     with open(config.UMU_CONFIG_NAME, "rb") as toml_file:
         toml_conf = tomllib.load(toml_file)
 
-        if not os.path.exists(toml_conf["umu"]["prefix"]):
-            os.mkdir(toml_conf["umu"]["prefix"])
+        prefix_path = Path(toml_conf["umu"]["prefix"])
+        if not prefix_path.exists():
+            prefix_path.mkdir()
 
         os.environ.update(toml_conf.get("env", {}))
         subprocess.run(

umu_commander/util.py

@@ -1,117 +1,58 @@
-from umu_commander import VERSION
-from umu_commander.classes import Element, Group, Value
-
-
-def string_to_value(value: str) -> Value:
-    return Value(value)
-
-
-def strings_to_values(values: list[str]) -> list[Value]:
-    return [string_to_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("")
-
+from collections.abc import Iterable
+from pathlib import Path
 
-def _translate_index_to_selection(
-    selection_index: int,
-    selection_elements: list[Element],
-    selection_groups: list[Group],
-) -> Element:
-    len_counter: int = 0
+from InquirerPy.base.control import Choice
+from InquirerPy.separator import Separator
 
-    if selection_elements is not None:
-        selection_groups.insert(0, Group(elements=selection_elements))
+from umu_commander import VERSION
+from umu_commander import database as db
+from umu_commander.classes import Element
 
-    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 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 get_selection(
-    prompt: str,
-    selection_elements: list[Element] | None,
-    selection_groups: list[Group] | None,
-    default_element: Element = None,
-) -> Element:
-    if not _selection_set_valid(selection_elements, selection_groups):
-        print("Nothing to select from.")
-        raise ValueError
-
-    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: str = input("? ")
-        print("")
-        if selection == "":
-            if default_element is not None:
-                return default_element
-
-            # If only 1 choice
-            if len(selection_groups) == 0 and len(selection_elements) == 1:
-                return selection_elements[0]
-
-            # len(selection_groups) == 1 and len(selection_groups[0].elements) == 1
-            groups_with_one_element: list[Group] = [
-                group for group in selection_groups if len(group.elements) == 1
+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(""),
             ]
-            if len(groups_with_one_element) == 1:
-                return groups_with_one_element[0].elements[0]
-
-        elif selection.isdecimal():
-            selection: int = int(selection) - 1
-            if enum_start_idx - 1 > selection >= 0:
-                break
+        )
 
-    return _translate_index_to_selection(
-        selection, selection_elements, selection_groups
-    )
+    return choices
 
 
 def print_help():

{umu_commander-1.6.2.dist-info → umu_commander-1.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: umu-commander
-Version: 1.6.2
+Version: 1.7.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
@@ -11,11 +11,14 @@ 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 an interactive CLI tool to augment umu-launcher as well as help you manage its Proton versions.
+### 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.
 
@@ -26,17 +29,18 @@ The configuration file lives at `~/.config/umu-commander.toml`, which cannot be
 
 The config schema is as follows:
 
-| Name                      | Description                                                        |
-|:--------------------------|:-------------------------------------------------------------------|
-| `PROTON_PATHS`            | List of directories umu-commander will search for Proton versions. |
-| `UMU_PROTON_PATH`         | Directory where umu-launcher downloads its UMU-Proton versions.    |
-| `DB_NAME`                 | Tracking DB filename.                                              |
-| `DB_DIR`                  | Directory where the Tracking DB is stored.                         |
-| `UMU_CONFIG_NAME`         | Name of the umu config created using umu-commander create.         |
-| `DEFAULT_PREFIX_DIR`      | Directory where umu-commander will search for WINE prefixes.       |
-| `[DLL_OVERRIDES_OPTIONS]` | TOML table where all possible DLL overrides are listed.            |
-
-To add an extra DLL override option, add a line below the table in the form "`Label`" = "`WINE override string`". Use the winhttp example as a template.
+| 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:

umu_commander-1.7.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+umu_commander/__init__.py,sha256=89F2IQARHlHjXGiEH_BGITazcP0AvMuV3rjFPaIQHDE,19
+umu_commander/__main__.py,sha256=RP6aH0JeYXb69P_gbFmlM_hsALUor4Sf4RENJ-oYs2I,2460
+umu_commander/classes.py,sha256=k2ymgDkVdG0-yBLJsByfbgx4qi4fIOU0RXAQcSdlK-A,363
+umu_commander/configuration.py,sha256=dUM4esIU8fj7Ts0pA8jM7bwhldsZbnRJdYlaNpfQuWg,2866
+umu_commander/database.py,sha256=Ix5ISzUKWF0xs3BUfhB8-azmKiWgP3NiaviKMydI-0E,1890
+umu_commander/proton.py,sha256=ZYew3Yn4m02tY0Y13E6loMSdxRSOIHA4t-1_BnxZa4g,1962
+umu_commander/tracking.py,sha256=ugorxaI_g7pNYR5BfUowcRzdciMg0Fin6bqNxyBli2w,3302
+umu_commander/umu_config.py,sha256=7U9888VP-rW61lFWfZsHMbCq_5_Q3-vqS4Y8trdMupU,4223
+umu_commander/util.py,sha256=ZTi3yrvGHy0Rr8xKEzloT-xcwCSHgDqBsH36oftOKiE,1817
+umu_commander-1.7.0.dist-info/METADATA,sha256=yCgJWJbntlR-HkurqJR5Dlutyajrqhjh1D6kseld0Uo,5920
+umu_commander-1.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+umu_commander-1.7.0.dist-info/entry_points.txt,sha256=ljyUmDmgCCMm7mQgB1syoWbf_5AiemyrS6YN7eTn9CI,62
+umu_commander-1.7.0.dist-info/licenses/LICENSE.txt,sha256=yipFXBRmVZ2Q44x1q18HccPUAECBQLXAOAr21aS57uY,1071
+umu_commander-1.7.0.dist-info/RECORD,,

umu_commander-1.6.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-umu_commander/__init__.py,sha256=eKShG3zJqAmg0Iu_xbUNkhAa7HaW-1-IthmdvuW6whs,19
-umu_commander/__main__.py,sha256=b5T4HnlLYreaLL9rbr0p7xT4roIoMJ8qJO3o_tcpK_M,2352
-umu_commander/classes.py,sha256=3vEC7Iq3buEUaIIJKO1ze57hs9yQ_-9pnkazHkSfcLk,1655
-umu_commander/configuration.py,sha256=bF_1n_8PQ04GmJZpC1scQ5OBZbsVXPstJ9RGfKE-D5k,2277
-umu_commander/database.py,sha256=mkBX0e6YEv2dWU2hCMaZwhSD02f_XefW0qbErcVHHYo,1183
-umu_commander/proton.py,sha256=K3KhaXxZawOZN84XKhXKP-HkIrW-sLSbMwoKBL2SrAU,2552
-umu_commander/tracking.py,sha256=WfWeQWnNNK_q-1rFt0HPFNDD8z7VcTCYKI5A_W8xNIg,3113
-umu_commander/umu_config.py,sha256=cePb3uKcf2WU4fwyQrqXJvlXmP7Riihc1guWfNAyT2c,4230
-umu_commander/util.py,sha256=8zn0c3gyAuZ8uuiDga4amsOYGFRy2FwzADsyJ1au0LY,3671
-umu_commander-1.6.2.dist-info/METADATA,sha256=nuaRiii5hRfKQ4toY-4w2Zq3aSIsDN0OpQmSm6Mo-5o,5391
-umu_commander-1.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-umu_commander-1.6.2.dist-info/entry_points.txt,sha256=ljyUmDmgCCMm7mQgB1syoWbf_5AiemyrS6YN7eTn9CI,62
-umu_commander-1.6.2.dist-info/licenses/LICENSE.txt,sha256=yipFXBRmVZ2Q44x1q18HccPUAECBQLXAOAr21aS57uY,1071
-umu_commander-1.6.2.dist-info/RECORD,,