feat(gcode_shell_command): allowing for expanding env vars (#747)

allowing for expanding env vars

kiauh/components/klipper/klipper_utils.py

@@ -237,7 +237,6 @@ def install_input_shaper_deps() -> None:
             "If you agree, the following additional system packages will be installed:",
             "● python3-numpy",
             "● python3-matplotlib",
-            "● libatlas-base-dev",
             "● libopenblas-dev",
             "\n\n",
             "Also, the following Python package will be installed:",
@@ -253,7 +252,6 @@ def install_input_shaper_deps() -> None:
     apt_deps = (
         "python3-numpy",
         "python3-matplotlib",
-        "libatlas-base-dev",
         "libopenblas-dev",
     )
     check_install_dependencies({*apt_deps})

kiauh/components/moonraker/utils/utils.py

@@ -123,7 +123,7 @@ def create_example_moonraker_conf(
     scp = SimpleConfigParser()
     scp.read_file(target)
     trusted_clients: List[str] = [
-        f"    {'.'.join(ip)}\n",
+        f"{'.'.join(ip)}",
         *scp.getvals("authorization", "trusted_clients"),
     ]
 

kiauh/components/webui_client/client_utils.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import json
 import re
 import shutil
+from json import JSONDecodeError
 from pathlib import Path
 from subprocess import PIPE, CalledProcessError, run
 from typing import List, get_args
@@ -151,18 +152,36 @@ def symlink_webui_nginx_log(
 def get_local_client_version(client: BaseWebClient) -> str | None:
     relinfo_file = client.client_dir.joinpath("release_info.json")
     version_file = client.client_dir.joinpath(".version")
+    default = "n/a"
 
     if not client.client_dir.exists():
-        return None
-    if not relinfo_file.is_file() and not version_file.is_file():
-        return "n/a"
+        return default
 
+    # try to get version from release_info.json first
     if relinfo_file.is_file():
-        with open(relinfo_file, "r") as f:
-            return str(json.load(f)["version"])
-    else:
-        with open(version_file, "r") as f:
-            return f.readlines()[0]
+        try:
+            if relinfo_file.stat().st_size == 0:
+                raise JSONDecodeError("Empty file", "", 0)
+            with open(relinfo_file, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            raw_version = data.get("version")
+            if raw_version is not None:
+                parsed = str(raw_version).strip()
+                if parsed:
+                    return parsed
+        except (JSONDecodeError, OSError):
+            Logger.print_error("Invalid 'release_info.json'")
+
+    # fallback to .version file
+    if version_file.is_file():
+        try:
+            with open(version_file, "r") as f:
+                line = f.readline().strip()
+            return line or default
+        except OSError:
+            Logger.print_error("Unable to read '.version'")
+
+    return default
 
 
 def get_remote_client_version(client: BaseWebClient) -> str | None:

kiauh/core/menus/backup_menu.py

@@ -58,7 +58,7 @@ class BackupMenu(BaseMenu):
 
     def print_menu(self) -> None:
         line1 = Color.apply(
-            "INFO: Backups are located in '~/kiauh-backups'", Color.YELLOW
+            "INFO: Backups are located in '~/kiauh_backups'", Color.YELLOW
         )
         menu = textwrap.dedent(
             f"""

kiauh/core/services/backup_service.py

@@ -62,16 +62,16 @@ class BackupService:
                 target_name
                 or f"{source_path.stem}_{self.timestamp}{source_path.suffix}"
             )
-            if target_path is not None:
-                backup_path = self._backup_root.joinpath(target_path, filename)
-            else:
-                backup_path = self._backup_root.joinpath(filename)
 
-            backup_path.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(source_path, backup_path)
+            backup_dir = self._backup_root
+            if target_path is not None:
+                backup_dir = self._backup_root.joinpath(target_path)
+
+            backup_dir.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(source_path, backup_dir.joinpath(filename))
 
             Logger.print_ok(
-                f"Successfully backed up '{source_path}' to '{backup_path}'"
+                f"Successfully backed up '{source_path}' to '{backup_dir}'"
             )
             return True
 
@@ -109,7 +109,16 @@ class BackupService:
             else:
                 backup_path = self._backup_root.joinpath(backup_dir_name)
 
-            shutil.copytree(source_path, backup_path)
+            if backup_path.exists():
+                Logger.print_info(f"Reusing existing backup directory '{backup_path}'")
+
+            shutil.copytree(
+                source_path,
+                backup_path,
+                dirs_exist_ok=True,
+                symlinks=True,
+                ignore_dangling_symlinks=True,
+            )
 
             Logger.print_ok(
                 f"Successfully backed up '{source_path}' to '{backup_path}'"

kiauh/core/settings/kiauh_settings.py

@@ -254,32 +254,34 @@ class KiauhSettings:
         section: str,
         option: str,
         getter: Callable[[str, str, T | None], T],
-        fallback: T = None,
+        fallback: T | None = None,
         silent: bool = False,
-    ) -> T:
+    ) -> T | None:
         if not self.__check_option_exists(section, option, fallback, silent):
             return fallback
         return getter(section, option, fallback)
 
     def __set_repo_state(self, section: str, repos: List[str]) -> List[Repository]:
         _repos: List[Repository] = []
-        for repo in repos:
-            try:
-                if repo.strip().startswith("#") or repo.strip().startswith(";"):
-                    continue
-                if "," in repo:
-                    url, branch = repo.strip().split(",")
+        for raw in repos:
+            line = raw.strip()
 
-                    if not branch:
-                        branch = "master"
+            if not line or line.startswith("#") or line.startswith(";"):
+                continue
+
+            try:
+                if "," in line:
+                    url_part, branch_part = line.split(",")
+                    url = url_part.strip()
+                    branch = branch_part.strip() or "master"
                 else:
-                    url = repo.strip()
+                    url = line
                     branch = "master"
 
                 # url must not be empty otherwise it's considered
                 # as an unrecoverable, invalid configuration
                 if not url:
-                    raise InvalidValueError(section, "repositories", repo)
+                    raise InvalidValueError(section, "repositories", line)
 
                 _repos.append(Repository(url.strip(), branch.strip()))
 

kiauh/core/submodules/simple_config_parser/src/simple_config_parser/simple_config_parser.py

@@ -12,7 +12,7 @@ import re
 from dataclasses import dataclass, field
 from enum import Enum
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Set, Union
+from typing import Any, Callable, Dict, List, Set, Union
 
 # definition of section line:
 #  - the line MUST start with an opening square bracket - it is the first section marker
@@ -91,6 +91,9 @@ class LineType(Enum):
     BLANK = "blank"
 
 
+_UNSET = object()
+
+
 class NoSectionError(Exception):
     """Raised when a section is not defined"""
 
@@ -342,7 +345,7 @@ class SimpleConfigParser:
             for line in file:
                 self._parse_line(line)
 
-    def write_file(self, path: Union[str, Path]) -> None:
+    def write_file(self, path: str | Path) -> None:
         """Write the config to a file"""
         if path is None:
             raise ValueError("File path cannot be None")
@@ -418,9 +421,7 @@ class SimpleConfigParser:
         """Check if an option exists in a section"""
         return self.has_section(section) and option in self.get_options(section)
 
-    def set_option(
-        self, section: str, option: str, value: Union[str, List[str]]
-    ) -> None:
+    def set_option(self, section: str, option: str, value: str | List[str]) -> None:
         """
         Set the value of an option in a section. If the section does not exist,
         it is created. If the option does not exist, it is created.
@@ -467,8 +468,8 @@ class SimpleConfigParser:
         elif opt and isinstance(opt, Option) and isinstance(value, str):
             curr_val = opt.value
             new_val = value
-            opt.value = value
-            opt.raw.replace(curr_val, new_val)
+            opt.value = new_val
+            opt.raw = opt.raw.replace(curr_val, new_val)
 
         elif opt and isinstance(opt, MultiLineOption) and isinstance(value, list):
             # note: we completely replace the existing values
@@ -561,7 +562,7 @@ class SimpleConfigParser:
             else self._find_option_by_name(option, section=sects[0])
         )
 
-    def getval(self, section: str, option: str, fallback: Optional[str] = None) -> str:
+    def getval(self, section: str, option: str, fallback: str | _UNSET = _UNSET) -> str:
         """
         Return the value of the given option in the given section
 
@@ -576,12 +577,12 @@ class SimpleConfigParser:
             return opt.value if opt else ""
 
         except (NoSectionError, NoOptionError):
-            if fallback is None:
+            if fallback is _UNSET:
                 raise
             return fallback
 
     def getvals(
-        self, section: str, option: str, fallback: Optional[List[str]] = None
+        self, section: str, option: str, fallback: List[str] | _UNSET = _UNSET
     ) -> List[str]:
         """
         Return the values of the given multi-line option in the given section
@@ -597,22 +598,22 @@ class SimpleConfigParser:
             return [v.value for v in opt.values] if opt else []
 
         except (NoSectionError, NoOptionError):
-            if fallback is None:
+            if fallback is _UNSET:
                 raise
             return fallback
 
-    def getint(self, section: str, option: str, fallback: Optional[int] = None) -> int:
+    def getint(self, section: str, option: str, fallback: int | _UNSET = _UNSET) -> int:
         """Return the value of the given option in the given section as an int"""
         return self._get_conv(section, option, int, fallback=fallback)
 
     def getfloat(
-        self, section: str, option: str, fallback: Optional[float] = None
+        self, section: str, option: str, fallback: float | _UNSET = _UNSET
     ) -> float:
         """Return the value of the given option in the given section as a float"""
         return self._get_conv(section, option, float, fallback=fallback)
 
     def getboolean(
-        self, section: str, option: str, fallback: Optional[bool] = None
+        self, section: str, option: str, fallback: bool | _UNSET = _UNSET
     ) -> bool:
         """Return the value of the given option in the given section as a boolean"""
         return self._get_conv(
@@ -631,14 +632,14 @@ class SimpleConfigParser:
         self,
         section: str,
         option: str,
-        conv: Callable[[str], Union[int, float, bool]],
-        fallback: Optional[Any] = None,
-    ) -> Union[int, float, bool]:
+        conv: Callable[[str], int | float | bool],
+        fallback: Any = _UNSET,
+    ) -> int | float | bool:
         """Return the value of the given option in the given section as a converted value"""
         try:
             return conv(self.getval(section, option, fallback))
         except (ValueError, TypeError, AttributeError) as e:
-            if fallback is not None:
+            if fallback is not _UNSET:
                 return fallback
             raise ValueError(
                 f"Cannot convert {self.getval(section, option)} to {conv.__name__}"

kiauh/extensions/gcode_shell_cmd/assets/gcode_shell_command.py

@@ -16,6 +16,7 @@ class ShellCommand:
         self.gcode = self.printer.lookup_object("gcode")
         cmd = config.get("command")
         cmd = os.path.expanduser(cmd)
+        cmd = os.path.expandvars(cmd)
         self.command = shlex.split(cmd)
         self.timeout = config.getfloat("timeout", 2.0, above=0.0)
         self.verbose = config.getboolean("verbose", True)

kiauh/extensions/spoolman/spoolman_extension.py

@@ -8,6 +8,7 @@
 # ======================================================================= #
 
 import re
+from pathlib import Path
 from subprocess import CalledProcessError, run
 from typing import List, Tuple
 
@@ -311,13 +312,19 @@ class SpoolmanExtension(BaseExtension):
         mrsvc.load_instances()
         mr_instances = mrsvc.get_all_instances()
         for instance in mr_instances:
-            asvc_path = instance.data_dir.joinpath("moonraker.asvc")
-            if asvc_path.exists():
-                if "Spoolman" in open(asvc_path).read():
-                    Logger.print_info(f"Spoolman already in {asvc_path}. Skipping...")
-                    continue
+            asvc_path: Path = instance.data_dir.joinpath("moonraker.asvc")
+            if asvc_path.exists() and asvc_path.is_file():
+                with open(asvc_path, "a+") as f:
+                    if "Spoolman" in f.read():
+                        Logger.print_info(
+                            f"Spoolman already in {asvc_path}. Skipping..."
+                        )
+                        continue
+
+                    content: List[str] = f.readlines()
+                    if content and not content[-1].endswith("\n"):
+                        f.write("\n")
 
-                with open(asvc_path, "a") as f:
                     f.write("Spoolman\n")
 
                 Logger.print_ok(f"Spoolman added to {asvc_path}!")