umu-commander 1.4.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

umu_commander/classes.py

@@ -1,14 +1,25 @@
 from dataclasses import dataclass
+from enum import Enum
 
 
-# analogous to Proton version
 @dataclass
 class Element:
     group_id: str = ""
     value: str = ""
     info: str = ""
 
-    # proton terminology for convenience
+    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
@@ -21,23 +32,50 @@ class Element:
     def user_count(self):
         return self.info
 
-    @user_count.setter
-    def user_count(self, value):
-        self.info = value
+
+@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)
 
 
-# analogous to Proton directory
 @dataclass
 class Group:
     identity: str = ""
     label: str = ""
     elements: list[Element] = list
 
-    # proton terminology for convenience
+
+@dataclass
+class ProtonDir(Group):
     @property
     def path(self):
         return self.identity
 
     @property
-    def versions(self):
-        return self.elements
+    def versions(self) -> list[ProtonVer]:
+        return [e.as_proton_ver() for e in self.elements]
+
+    @versions.setter
+    def versions(self, value):
+        self.elements = value
+
+
+class ExitCode(Enum):
+    SUCCESS = 0
+    READING_ERROR = 1
+    INVALID_SELECTION = 2

umu_commander/configuration.py

@@ -1,22 +1,72 @@
 import os
+import tomllib
 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;")
-]
+import tomli_w
+
+from umu_commander.classes import DLLOverride
+
+CONFIG_DIR: str = os.path.join(Path.home(), ".config")
+CONFIG_NAME: str = "umu-commander.toml"
+
+
+class Configuration:
+    PROTON_PATHS: tuple[str, ...] = (
+        os.path.join(Path.home(), ".local/share/Steam/compatibilitytools.d/"),
+        os.path.join(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;"),
+    )
+
+    @staticmethod
+    def load():
+        try:
+            with open(os.path.join(CONFIG_DIR, CONFIG_NAME), "rb") as conf_file:
+                toml_conf = tomllib.load(conf_file)
+                toml_conf["DLL_OVERRIDES_OPTIONS"] = tuple(
+                    [
+                        DLLOverride(label, override_str)
+                        for label, override_str in toml_conf[
+                            "DLL_OVERRIDES_OPTIONS"
+                        ].items()
+                    ]
+                )
+
+                for key, value in toml_conf.items():
+                    setattr(Configuration, key, value)
+
+        except FileNotFoundError:
+            Configuration.dump()
+
+    @staticmethod
+    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 = Configuration._get_attributes()
+            toml_conf["DLL_OVERRIDES_OPTIONS"] = dict(
+                [
+                    (override.info, override.value)
+                    for override in Configuration.DLL_OVERRIDES_OPTIONS
+                ]
+            )
+
+            tomli_w.dump(toml_conf, conf_file)
+
+    @staticmethod
+    def _get_attributes():
+        attributes = {}
+        for key, value in vars(Configuration).items():
+            if not key.startswith("__") and not callable(getattr(Configuration, key)):
+                attributes[key] = value
+
+        return attributes

umu_commander/database.py

@@ -0,0 +1,43 @@
+import json
+import os
+from collections import defaultdict
+
+from umu_commander.configuration import Configuration as config
+
+
+class Database:
+    _db: defaultdict[str, defaultdict[str, list[str]]]
+
+    @staticmethod
+    def load():
+        if not os.path.exists(config.DB_DIR):
+            os.mkdir(config.DB_DIR)
+
+        try:
+            with open(os.path.join(config.DB_DIR, config.DB_NAME), "rt") as db_file:
+                Database._db = defaultdict(lambda: defaultdict(list))
+                Database._db.update(json.load(db_file))
+
+        except FileNotFoundError:
+            Database._db = defaultdict(lambda: defaultdict(list))
+
+    @staticmethod
+    def dump():
+        with open(os.path.join(config.DB_DIR, config.DB_NAME), "wt") as db_file:
+            # noinspection PyTypeChecker
+            json.dump(Database._db, db_file, indent="\t")
+
+    @staticmethod
+    def get(
+        proton_dir: str = None, proton_ver: str = None
+    ) -> dict[str, dict[str, list[str]]] | dict[str, list[str]] | list[str]:
+        if proton_dir is None and proton_ver is None:
+            return Database._db
+
+        if proton_ver is None:
+            return Database._db[proton_dir]
+
+        if proton_ver not in Database._db[proton_dir]:
+            Database._db[proton_dir][proton_ver] = []
+
+        return Database._db[proton_dir][proton_ver]

umu_commander/main.py

@@ -1,9 +1,13 @@
 #!/usr/bin/python3
+import os
 import sys
 from json import JSONDecodeError
 
-from umu_commander import db, tracking, umu_config
-from umu_commander.configuration import *
+from umu_commander import tracking, umu_config
+from umu_commander.classes import ExitCode
+from umu_commander.configuration import CONFIG_DIR, CONFIG_NAME
+from umu_commander.configuration import Configuration as config
+from umu_commander.database import Database as db
 
 
 def print_help():
@@ -15,16 +19,24 @@ def print_help():
     )
 
 
-def main() -> int:
+def main() -> ExitCode:
+    try:
+        config.load()
+    except (JSONDecodeError, KeyError):
+        config_path: str = os.path.join(CONFIG_DIR, CONFIG_NAME)
+        print(f"Config file at {config_path} could not be read.")
+        os.rename(config_path, os.path.join(CONFIG_DIR, CONFIG_NAME + ".old"))
+
     try:
         db.load()
     except JSONDecodeError:
-        print(f"Tracking file at {os.path.join(DB_DIR, DB_NAME)} could not be read.")
-        return 2
+        db_path: str = os.path.join(config.DB_DIR, config.DB_NAME)
+        print(f"Tracking file at {db_path} could not be read.")
+        os.rename(db_path, os.path.join(config.DB_DIR, config.DB_NAME + ".old"))
 
     if len(sys.argv) == 1:
         print_help()
-        return 0
+        return ExitCode.SUCCESS
 
     verb: str = sys.argv[1]
     match verb:
@@ -43,13 +55,14 @@ def main() -> int:
         case _:
             print("Invalid verb.")
             print_help()
-            return 3
+            return ExitCode.INVALID_SELECTION
 
     tracking.untrack_unlinked()
     db.dump()
+    config.dump()
 
-    return 0
+    return ExitCode.SUCCESS
 
 
 if __name__ == "__main__":
-    exit(main())
+    exit(main().value)

umu_commander/proton.py

@@ -2,12 +2,13 @@ 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
+from umu_commander.classes import ProtonDir, ProtonVer
+from umu_commander.configuration import Configuration as config
+from umu_commander.database import Database as db
 
 
-def _natural_sort_proton_ver_key(e: Element, _nsre=re.compile(r"(\d+)")):
-    s: str = e.value
+def _natural_sort_proton_ver_key(p: ProtonVer, _nsre=re.compile(r"(\d+)")):
+    s: str = p.version_num
     return [int(text) if text.isdigit() else text for text in _nsre.split(s)]
 
 
@@ -31,33 +32,48 @@ def refresh_proton_versions():
             break
 
 
-def _sort_proton_versions(versions: list[Element]) -> list[Element]:
+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) -> list[Group]:
-    version_groups: list[Group] = []
-    for proton_dir in PROTON_DIRS:
-        versions: list[Element] = [
-            Element(proton_dir, version, "")
+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] = []
+    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 version != DB_NAME
+            if os.path.isdir(os.path.join(proton_dir, version))
         ]
+
         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)
+        proton_dirs.append(
+            ProtonDir(proton_dir, f"Proton versions in {proton_dir}:", versions)
         )
 
-    return version_groups
+    return proton_dirs
 
 
 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: 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))
     ]
     umu_proton_versions = sorted(
         umu_proton_versions, key=_natural_sort_proton_ver_key, reverse=True

umu_commander/tracking.py

@@ -1,8 +1,8 @@
+import os
 import shutil
 
-from umu_commander import db
-from umu_commander.classes import Group
-from umu_commander.configuration import *
+from umu_commander.classes import ProtonDir, ProtonVer
+from umu_commander.database import Database as db
 from umu_commander.proton import (
     collect_proton_versions,
     get_latest_umu_proton,
@@ -15,55 +15,49 @@ from umu_commander.util import (
 
 def untrack(quiet: bool = False):
     current_dir: str = os.getcwd()
-    for proton_dir in db.copy().keys():
+    for proton_dir in db.get().keys():
         for proton_ver in db.get(proton_dir):
-            db.remove_from(proton_dir, proton_ver, current_dir)
+            if current_dir in db.get(proton_dir, proton_ver):
+                db.get(proton_dir, proton_ver).remove(current_dir)
 
     if not quiet:
         print("Directory removed from all user lists.")
 
 
-def track(proton: Element = None, refresh_versions: bool = True, quiet: bool = False):
+def track(
+    proton_ver: ProtonVer = None, refresh_versions: bool = True, quiet: bool = False
+):
     if refresh_versions:
         refresh_proton_versions()
 
-    if proton is None:
-        proton: Element = get_selection(
+    if proton_ver is None:
+        proton_ver: ProtonVer = get_selection(
             "Select Proton version to add directory as user:",
             None,
             collect_proton_versions(sort=True),
-        )
+        ).as_proton_ver()
 
     untrack(quiet=True)
     current_directory: str = os.getcwd()
-    db.add_to(proton.dir, proton.version_num, current_directory)
+    db.get(proton_ver.dir, proton_ver.version_num).append(current_directory)
 
     if not quiet:
         print(
-            f"Directory {current_directory} added to Proton version's {proton.version_num} in {proton.dir} user list."
+            f"Directory {current_directory} added to Proton version's {proton_ver.version_num} in {proton_ver.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_dirs: list[ProtonDir] = collect_proton_versions(sort=True, user_count=True)
 
-    proton: Element = get_selection(
-        "Select Proton version to view user list:", None, proton_version_dirs
-    )
+    proton_ver: ProtonVer = get_selection(
+        "Select Proton version to view user list:", None, proton_dirs
+    ).as_proton_ver()
 
-    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 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)
         if len(version_users) > 0:
-            print(f"Directories using {proton.version_num} of {proton.dir}:")
+            print(f"Directories using {proton_ver.version_num} of {proton_ver.dir}:")
             print(*version_users, sep="\n")
         else:
             print("No directories currently use this version.")
@@ -72,7 +66,7 @@ def users():
 
 
 def delete():
-    for proton_dir in db.copy().keys():
+    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
@@ -86,12 +80,12 @@ def delete():
                         shutil.rmtree(os.path.join(proton_dir, proton_ver))
                     except FileNotFoundError:
                         pass
-                    db.delete(proton_dir, proton_ver)
+                    del db.get(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 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):
-                    db.remove_from(proton_dir, proton_ver, user)
+                    db.get(proton_dir, proton_ver).remove(user)

umu_commander/umu_config.py

@@ -1,67 +1,56 @@
+import os
 import subprocess
 import tomllib
-from collections.abc import Mapping
 from typing import Any
 
+import tomli_w
+
 from umu_commander import tracking
-from umu_commander.configuration import *
+from umu_commander.classes import DLLOverride, ProtonVer
+from umu_commander.configuration import Configuration as config
 from umu_commander.proton import collect_proton_versions, refresh_proton_versions
 from umu_commander.util import (
     get_selection,
-    values_to_elements,
+    strings_to_values,
 )
 
 
-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": {}}
+    params: dict[str, Any] = {"umu": {}, "env": {}}
 
     # Prefix selection
     selection: str = get_selection(
         "Select wine prefix:",
-        values_to_elements([*os.listdir(PREFIX_DIR), "Current directory"]),
+        strings_to_values(
+            [*os.listdir(config.DEFAULT_PREFIX_DIR), "Current directory"]
+        ),
         None,
     ).value
 
     if selection == "Current directory":
-        params["prefix"] = os.path.join(os.getcwd(), "prefix")
+        params["umu"]["prefix"] = os.path.join(os.getcwd(), "prefix")
     else:
-        params["prefix"] = os.path.join(PREFIX_DIR, selection)
+        params["umu"]["prefix"] = os.path.join(config.DEFAULT_PREFIX_DIR, selection)
 
     # Proton selection
     selected_umu_latest: bool = False
-    proton: Element = get_selection(
+    proton_ver: ProtonVer = get_selection(
         "Select Proton version:",
-        values_to_elements(["Always latest UMU Proton"]),
-        [*collect_proton_versions(sort=True)],
-    )
-    if proton.value == "Always latest UMU Proton":
+        strings_to_values(["Always latest UMU Proton"]),
+        collect_proton_versions(sort=True),
+    ).as_proton_ver()
+    if proton_ver.version_num == "Always latest UMU Proton":
         selected_umu_latest = True
     else:
-        params["proton"] = os.path.join(proton.dir, proton.version_num)
+        params["umu"]["proton"] = os.path.join(proton_ver.dir, proton_ver.version_num)
 
     # Select DLL overrides
-    possible_overrides: list[Element] = [
-        Element(info="Reset"),
-        Element(info="Done"),
-        *DLL_OVERRIDES_OPTIONS,
+    possible_overrides: list[DLLOverride] = [
+        DLLOverride(label="Reset"),
+        DLLOverride(label="Done"),
+        *config.DLL_OVERRIDES_OPTIONS,
     ]
     selected: set[int] = set()
     while True:
@@ -69,7 +58,7 @@ def create():
         for idx, override in enumerate(possible_overrides):
             if idx in selected:
                 idx = "Y"
-            print(f"{idx}) {override.info}")
+            print(f"{idx}) {override.label}")
 
         try:
             index: int = int(input("? "))
@@ -92,12 +81,14 @@ def create():
         params["env"]["WINEDLLOVERRIDES"] = ""
         for selection in selected:
             # noinspection PyTypeChecker
-            params["env"]["WINEDLLOVERRIDES"] += possible_overrides[selection].value
+            params["env"]["WINEDLLOVERRIDES"] += possible_overrides[
+                selection
+            ].override_str
 
     # Set language locale
     match get_selection(
         "Select locale:",
-        values_to_elements(["Default", "Japanese"]),
+        strings_to_values(["Default", "Japanese"]),
         None,
     ).value:
         case "Default":
@@ -109,7 +100,7 @@ def create():
     launch_args: list[str] = input(
         "Enter executable options, separated by spaces:\n? "
     ).split()
-    params["launch_args"] = launch_args
+    params["umu"]["launch_args"] = launch_args
 
     # Select executable name
     files: list[str] = [
@@ -118,30 +109,31 @@ def create():
         if os.path.isfile(os.path.join(os.getcwd(), file))
     ]
     executable_name: str = get_selection(
-        "Select game executable:", values_to_elements(files), None
+        "Select game executable:", strings_to_values(files), None
     ).value
-    params["exe"] = executable_name
+    params["umu"]["exe"] = executable_name
 
     try:
-        _write(params)
-        print(f"Configuration file {CONFIG_NAME} created at {os.getcwd()}.")
+        with open(config.UMU_CONFIG_NAME, "wb") as file:
+            tomli_w.dump(params, file)
+
+        print(f"Configuration file {config.UMU_CONFIG_NAME} created at {os.getcwd()}.")
         print(f"Use by running umu-commander run.")
         if not selected_umu_latest:
-            tracking.track(proton, False)
+            tracking.track(proton_ver, False)
     except:
-        print("Could not create configuration file.")
+        print("Could not create configiguration file.")
 
 
 def run():
-    with open(CONFIG_NAME, "rb") as toml_file:
-        # noinspection PyTypeChecker
-        config = tomllib.load(toml_file)
+    with open(config.UMU_CONFIG_NAME, "rb") as toml_file:
+        toml_conf = tomllib.load(toml_file)
 
-        if not os.path.exists(config["umu"]["prefix"]):
-            os.mkdir(config["umu"]["prefix"])
+        if not os.path.exists(toml_conf["umu"]["prefix"]):
+            os.mkdir(toml_conf["umu"]["prefix"])
 
-        os.environ.update(config.get("env", {}))
+        os.environ.update(toml_conf.get("env", {}))
         subprocess.run(
-            args=["umu-run", "--config", CONFIG_NAME],
+            args=["umu-run", "--config", config.UMU_CONFIG_NAME],
             env=os.environ,
         )

umu_commander/util.py

@@ -1,9 +1,8 @@
-from umu_commander.classes import Group
-from umu_commander.configuration import *
+from umu_commander.classes import Element, ExitCode, Group, Value
 
 
-def values_to_elements(values: list[str]) -> list[Element]:
-    return [Element(value=value) for value in values]
+def strings_to_values(values: list[str]) -> list[Value]:
+    return [Value(value) for value in values]
 
 
 def _selection_set_valid(
@@ -59,7 +58,7 @@ def get_selection(
 ) -> Element:
     if not _selection_set_valid(selection_elements, selection_groups):
         print("Nothing to select from.")
-        exit(4)
+        exit(ExitCode.INVALID_SELECTION)
 
     if selection_groups is None:
         selection_groups = []

{umu_commander-1.4.0.dist-info → umu_commander-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: umu-commander
-Version: 1.4.0
+Version: 1.5.2
 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
@@ -21,7 +21,15 @@ What directories each Proton version is being used by is tracked within `trackin
 
 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.
+### Config
+The configuration file lives at `~/.config/umu-commander.toml`. Within it, you can edit the following:
+* PROTON_PATHS: List of directories umu-commander will search for Proton versions.
+* UMU_PROTON_PATH: Directory where umu itself 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 run.
+* DEFAULT_PREFIX_DIR: Directory where WINE prefixes are scanned.
+* [DLL_OVERRIDES_OPTIONS]: Category to list possible DLL overrides in "Label" = "Override string" format.
 
 ### Verbs
 umu-commander needs one of the following verbs specified after the executable name:

umu_commander-1.5.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+umu_commander/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+umu_commander/classes.py,sha256=SW8k4TrP4-W4DdaQC_P88wBIgeJ3TIaV7lyt32IfVD8,1654
+umu_commander/configuration.py,sha256=tzVFoQx7M1RGGtP_c_k3IUVFNcLwsmjbQplTeKlFUnM,2398
+umu_commander/database.py,sha256=rkjEEy-Em9ghZOypsWyKTlNjDNMU4XXWuthnpfa6yz4,1343
+umu_commander/main.py,sha256=LWLLzMO2xm-45USc0Uw1-oTdPW14tOd0-WAbnLvFTQg,1966
+umu_commander/proton.py,sha256=QWqU5N2v-QqP_d-kFGXxXiCufLFQywnMNrbuLXaINZk,2572
+umu_commander/tracking.py,sha256=MVj-GfbROyqhKa-m6557RGCzavTxgphNBVPJNtSTe3k,3058
+umu_commander/umu_config.py,sha256=3b5XeTZppmLpxUGBHi4JSBc7zmKxNKjboldwGfLE0rc,4091
+umu_commander/util.py,sha256=mBRdLs-dnrTE_23qSb9wZ7tw4WmcNU3AS9oJFrVLgH4,2642
+umu_commander-1.5.2.dist-info/METADATA,sha256=E-8ommUma55wG-liyjohc6eaIh1IE3B6NxpMpx1Lzsg,3180
+umu_commander-1.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+umu_commander-1.5.2.dist-info/entry_points.txt,sha256=7RGP35zAHeEojZ-sv7JIITuMeH_VVNuG2g2_SUrUnbM,58
+umu_commander-1.5.2.dist-info/licenses/LICENSE.txt,sha256=yipFXBRmVZ2Q44x1q18HccPUAECBQLXAOAr21aS57uY,1071
+umu_commander-1.5.2.dist-info/RECORD,,

umu_commander/db.py

@@ -1,66 +0,0 @@
-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-1.4.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-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,,