machineconfig 7.64__py3-none-any.whl → 7.83__py3-none-any.whl

machineconfig/utils/installer_utils/installer_class.py

@@ -1,31 +1,16 @@
+from machineconfig.utils.installer_utils.installer_helper import install_deb_package
 from machineconfig.utils.path_extended import PathExtended, DECOMPRESS_SUPPORTED_FORMATS
 from machineconfig.utils.source_of_truth import INSTALL_TMP_DIR, INSTALL_VERSION_ROOT
 from machineconfig.utils.installer_utils.installer_locator_utils import find_move_delete_linux, find_move_delete_windows, check_tool_exists
 from machineconfig.utils.schemas.installer.installer_types import InstallerData, get_os_name, get_normalized_arch
+from machineconfig.utils.installer_utils.github_release_bulk import (
+    get_repo_name_from_url,
+    get_release_info,
+)
 
 import platform
 import subprocess
-import json
-from typing import Optional, Any
-from urllib.parse import urlparse
-
-
-
-def install_deb_package(downloaded: PathExtended) -> None:
-    print(f"📦 Installing .deb package: {downloaded}")
-    assert platform.system() == "Linux"
-    result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
-    success = result.returncode == 0 and result.stderr == ""
-    if not success:
-        desc = "Installing .deb"
-        print(f"❌ {desc} failed")
-        if result.stdout:
-            print(f"STDOUT: {result.stdout}")
-        if result.stderr:
-            print(f"STDERR: {result.stderr}")
-        print(f"Return code: {result.returncode}")
-    print("🗑️  Cleaning up .deb package...")
-    downloaded.delete(sure=True)
+from typing import Optional
 
 
 class Installer:
@@ -79,19 +64,23 @@ class Installer:
         version_to_be_installed: str = "unknown"  # Initialize to ensure it's always bound
         if repo_url == "CMD":
             if any(pm in installer_arch_os for pm in ["npm ", "pip ", "winget ", "brew ", "curl "]):
+                from rich import print as rprint
+                from rich.panel import Panel
+                from rich.console import Group
                 package_manager = installer_arch_os.split(" ", maxsplit=1)[0]
                 print(f"📦 Using package manager: {installer_arch_os}")
                 desc = package_manager + " installation"
                 version_to_be_installed = package_manager + "Latest"
-                result = subprocess.run(installer_arch_os, shell=True, capture_output=True, text=False)
-                success = result.returncode == 0 and result.stderr == "".encode()
+                result = subprocess.run(installer_arch_os, shell=True, capture_output=False, text=True)
+                success = result.returncode == 0 and result.stderr == ""
                 if not success:
-                    print(f"❌ {desc} failed")
+                    sub_panels = []
                     if result.stdout:
-                        print(f"STDOUT: {result.stdout}")
+                        sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
                     if result.stderr:
-                        print(f"STDERR: {result.stderr}")
-                    print(f"Return code: {result.returncode}")
+                        sub_panels.append(Panel(result.stderr, title="STDERR", style="red"))
+                    group_content = Group(f"❌ {desc} failed\nReturn code: {result.returncode}", *sub_panels)
+                    rprint(Panel(group_content, title=desc, style="red"))
             elif installer_arch_os.endswith((".sh", ".py", ".ps1")):
                 import machineconfig.jobs.installer as module
                 from pathlib import Path
@@ -117,7 +106,7 @@ class Installer:
                     import runpy
                     runpy.run_path(str(installer_path), run_name=None)["main"](self.installer_data, version=version)
                     version_to_be_installed = str(version)
-            elif installer_arch_os.startswith("https://"):  # its a url to be downloaded
+            elif installer_arch_os.startswith("https://") or installer_arch_os.startswith("http://"):
                 # downloaded_object = PathExtended(installer_arch_os).download(folder=INSTALL_TMP_DIR)
                 from machineconfig.scripts.python.helpers_utils.download import download
                 downloaded_object = download(installer_arch_os, output_dir=str(INSTALL_TMP_DIR))
@@ -213,44 +202,6 @@ class Installer:
             if only_file_in.is_file() and only_file_in.suffix in DECOMPRESS_SUPPORTED_FORMATS:  # further decompress
                 downloaded = only_file_in.decompress()
         return downloaded, version_to_be_installed
-    @staticmethod
-    def _get_repo_name_from_url(repo_url: str) -> str:
-        """Extract owner/repo from GitHub URL."""
-        try:
-            parsed = urlparse(repo_url)
-            path_parts = parsed.path.strip("/").split("/")
-            return f"{path_parts[0]}/{path_parts[1]}"
-        except (IndexError, AttributeError):
-            return ""
-
-    @staticmethod
-    def _fetch_github_release_data(repo_name: str, version: Optional[str] = None) -> Optional[dict[str, Any]]:
-        """Fetch release data from GitHub API using requests."""
-        import requests
-        try:
-            if version and version.lower() != "latest":  # Fetch specific version
-                url = f"https://api.github.com/repos/{repo_name}/releases/tags/{version}"
-            else:   # Fetch latest release
-                url = f"https://api.github.com/repos/{repo_name}/releases/latest"
-            response = requests.get(url, timeout=30)
-            if response.status_code != 200:
-                print(f"❌ Failed to fetch data for {repo_name}: HTTP {response.status_code}")
-                return None
-            response_data = response.json()
-            # Check if API returned an error
-            if "message" in response_data:
-                if "API rate limit exceeded" in response_data.get("message", ""):
-                    print(f"🚫 Rate limit exceeded for {repo_name}")
-                    return None
-                elif "Not Found" in response_data.get("message", ""):
-                    print(f"🔍 No releases found for {repo_name}")
-                    return None
-                    
-            return response_data
-            
-        except (requests.RequestException, requests.Timeout, json.JSONDecodeError) as e:
-            print(f"❌ Error fetching {repo_name}: {e}")
-            return None
 
     def get_github_release(self, repo_url: str, version: Optional[str]) -> tuple[Optional[str], Optional[str]]:
         """
@@ -262,20 +213,20 @@ class Installer:
         filename_pattern = self.installer_data["fileNamePattern"][arch][os_name]
         if filename_pattern is None:
             raise ValueError(f"No fileNamePattern for {self._get_exe_name()} on {os_name} {arch}")
-        repo_name = self._get_repo_name_from_url(repo_url)
-        if not repo_name:
+        repo_info = get_repo_name_from_url(repo_url)
+        if not repo_info:
             print(f"❌ Invalid repository URL: {repo_url}")
             return None, None
-        release_data = self._fetch_github_release_data(repo_name, version)
-        if not release_data:
+        username, repository = repo_info
+        release_info = get_release_info(username, repository, version)
+        if not release_info:
             return None, None        
-        # print(release_data)
-        actual_version = release_data.get("tag_name", "unknown")
+        actual_version = release_info.get("tag_name", "unknown") or "unknown"
         filename = filename_pattern.format(version=actual_version)
 
         available_filenames: list[str] = []
-        for asset in release_data.get("assets", []):
-            an_dl = asset.get("browser_download_url", "NA")
+        for asset in release_info["assets"]:
+            an_dl = asset["browser_download_url"]
             available_filenames.append(an_dl.split("/")[-1])
         if filename not in available_filenames:
             candidates = [

machineconfig/utils/installer_utils/installer_cli.py

@@ -1,11 +1,27 @@
-"""Devops Devapps Install"""
+"""Devops Devapps Install
 
+
+sudo apt update && sudo apt install -y \
+  git gcc g++ clang \
+  yasm nasm pkg-config \
+  meson ninja-build \
+  autoconf automake libtool \
+  libx11-dev libxext-dev libxrandr-dev libxrender-dev libxss-dev \
+  libvdpau-dev libgl1-mesa-dev libegl1-mesa-dev libxv-dev \
+  libasound2-dev libpulse-dev \
+  libfribidi-dev libfreetype-dev libfontconfig1-dev libharfbuzz-dev \
+  libjpeg-dev libssl-dev zlib1g-dev python3-pip
+
+
+"""
+
+from machineconfig.utils.installer_utils.installer_helper import get_group_name_to_repr
 import typer
-from typing import Optional, Annotated
-from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+from typing import Annotated, Optional
 
 
-def main(
+
+def main_installer_cli(
     which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program/groups names to install (if --group flag is set).")] = None,
     group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
     interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
@@ -25,6 +41,7 @@ def main(
             console = Console()
 
             typer.echo("❌ You must provide a group name when using the --group/-g option.")
+            from machineconfig.utils.installer_utils.installer_helper import get_group_name_to_repr
             res = get_group_name_to_repr()
             console.print("[bold blue]Here are the available groups:[/bold blue]")
             table = Table(show_header=True, header_style="bold magenta")
@@ -49,13 +66,7 @@ def main(
     raise typer.Exit(1)
 
 
-def get_group_name_to_repr() -> dict[str, str]:
-    # Build category options and maintain a mapping from display text to actual category name
-    category_display_to_name: dict[str, str] = {}
-    for group_name, group_values in PACKAGE_GROUP2NAMES.items():
-        display = f"📦 {group_name:<20}" + "   --   " + f"{'|'.join(group_values):<60}"
-        category_display_to_name[display] = group_name
-    return category_display_to_name
+
 
 
 def install_interactively():
@@ -95,6 +106,7 @@ def install_group(package_group: str):
     from rich.console import Console
     from rich.panel import Panel
     # from rich.table import Table
+    from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
     if package_group in PACKAGE_GROUP2NAMES:
         panel = Panel(f"[bold yellow]Installing programs from category: [green]{package_group}[/green][/bold yellow]", title="[bold blue]📦 Category Installation[/bold blue]", border_style="blue", padding=(1, 2))
         console = Console()
@@ -104,55 +116,34 @@ def install_group(package_group: str):
         return
     console = Console()
     console.print(f"❌ ERROR: Unknown package group: {package_group}. Available groups are: {list(PACKAGE_GROUP2NAMES.keys())}")
-def _handle_installer_not_found(search_term: str, all_names: list[str]) -> None:  # type: ignore
-    """Handle installer not found with friendly suggestions using fuzzy matching."""
-    from difflib import get_close_matches
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.table import Table
-    close_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
-    console = Console()
-
-    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
-    if close_matches:
-        console.print("🤔 Did you mean one of these?", style="yellow")
-        table = Table(show_header=False, box=None, pad_edge=False)
-        for i, match in enumerate(close_matches, 1):
-            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{match}[/green]")
-        console.print(table)
-    else:
-        console.print("📋 Here are some available options:", style="blue")
-        # Show first 10 installers as examples
-        if len(all_names) > 10:
-            sample_names = all_names[:10]
-        else:
-            sample_names = all_names
-        table = Table(show_header=False, box=None, pad_edge=False)
-        for i, name in enumerate(sample_names, 1):
-            table.add_row(f"[cyan]{i}.[/cyan]", f"[green]{name}[/green]")
-        console.print(table)
-        if len(all_names) > 10:
-            console.print(f"   [dim]... and {len(all_names) - 10} more[/dim]")
 
-    panel = Panel(f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(PACKAGE_GROUP2NAMES.keys())}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow")
-    console.print(panel)
 
 def install_clis(clis_names: list[str]):
     from machineconfig.utils.schemas.installer.installer_types import get_normalized_arch, get_os_name
     from machineconfig.utils.installer_utils.installer_runner import get_installers
     from machineconfig.utils.installer_utils.installer_class import Installer
     from rich.console import Console
+    all_installers_data = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
     total_messages: list[str] = []
-    for a_which in clis_names:
-        all_installers = get_installers(os=get_os_name(), arch=get_normalized_arch(), which_cats=None)
+    for a_cli_name in clis_names:
+        if "github.com" in a_cli_name.lower():
+            from machineconfig.utils.installer_utils.install_from_url import install_from_github_url
+            install_from_github_url(github_url=a_cli_name)
+            continue
+        elif a_cli_name.startswith("https://") or a_cli_name.startswith("http://"):
+            print(f"⏳ Installing from binary URL: {a_cli_name} ...")
+            from machineconfig.utils.installer_utils.install_from_url import install_from_binary_url
+            install_from_binary_url(a_cli_name)
+            continue
         selected_installer = None
-        for installer in all_installers:
+        for installer in all_installers_data:
             app_name = installer["appName"]
-            if app_name.lower() == a_which.lower():
+            if app_name.lower() == a_cli_name.lower():
                 selected_installer = installer
                 break
         if selected_installer is None:
-            _handle_installer_not_found(a_which, all_names=[inst["appName"] for inst in all_installers])
+            from machineconfig.utils.installer_utils.installer_helper import handle_installer_not_found
+            handle_installer_not_found(a_cli_name, all_installers_data)
             return None
         message = Installer(selected_installer).install_robust(version=None)  # finish the task
         total_messages.append(message)
@@ -169,13 +160,12 @@ def install_if_missing(which: str):
         print(f"✅ {which} is already installed.")
         return
     print(f"⏳ {which} not found. Installing...")
-    from machineconfig.utils.installer_utils.installer_cli import main
-    main(which=which, interactive=False)
+    from machineconfig.utils.installer_utils.installer_cli import main_installer_cli
+    main_installer_cli(which=which, interactive=False)
 
 
 if __name__ == "__main__":
     from machineconfig.utils.schemas.installer.installer_types import InstallerData
     from machineconfig.utils.installer_utils.installer_class import Installer
-
     _ = InstallerData, Installer
     pass

machineconfig/utils/installer_utils/installer_helper.py

@@ -0,0 +1,100 @@
+from machineconfig.jobs.installer.package_groups import PACKAGE_GROUP2NAMES
+from machineconfig.utils.schemas.installer.installer_types import InstallerData
+from pathlib import Path
+
+
+def get_group_name_to_repr() -> dict[str, str]:
+    # Build category options and maintain a mapping from display text to actual category name
+    category_display_to_name: dict[str, str] = {}
+    for group_name, group_values in PACKAGE_GROUP2NAMES.items():
+        display = f"📦 {group_name:<20}" + "   --   " + f"{'|'.join(group_values):<60}"
+        category_display_to_name[display] = group_name
+    return category_display_to_name
+
+
+def handle_installer_not_found(search_term: str, app_apps: list[InstallerData]) -> None:  # type: ignore
+    """Handle installer not found with friendly suggestions using fuzzy matching."""
+    from difflib import get_close_matches
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    all_names = sorted([inst["appName"] for inst in app_apps])
+    name_to_doc = {inst["appName"]: inst["doc"] for inst in app_apps}
+    all_descriptions = {f"{inst['appName']}: {inst['doc']}": inst["appName"] for inst in app_apps}
+
+    close_name_matches = get_close_matches(search_term, all_names, n=5, cutoff=0.4)
+    close_description_matches = get_close_matches(search_term, list(all_descriptions.keys()), n=5, cutoff=0.4)
+
+    search_lower = search_term.lower()
+    substring_matches = [
+        inst["appName"]
+        for inst in app_apps
+        if search_lower in inst["appName"].lower() or search_lower in inst["doc"].lower()
+    ]
+
+    ordered_matches: list[str] = list(
+        dict.fromkeys(
+            close_name_matches
+            + [all_descriptions[desc] for desc in close_description_matches]
+            + substring_matches
+        )
+    )
+    top_matches = ordered_matches[:10]
+    console = Console()
+
+    console.print(f"\n❌ '[red]{search_term}[/red]' was not found.", style="bold")
+    if top_matches:
+        console.print("🤔 Did you mean one of these?", style="yellow")
+        table = Table(show_header=True, header_style="bold", box=None, pad_edge=False)
+        table.add_column("#", justify="right", width=3)
+        table.add_column("Installer", style="green")
+        table.add_column("Description", style="dim", overflow="fold")
+        for i, match in enumerate(top_matches, 1):
+            table.add_row(f"[cyan]{i}[/cyan]", match, name_to_doc.get(match, ""))
+        console.print(table)
+    else:
+        console.print("📋 Here are some available options:", style="blue")
+        # Show first 10 installers as examples
+        if len(all_names) > 10:
+            sample_names = all_names[:10]
+        else:
+            sample_names = all_names
+        table = Table(show_header=True, header_style="bold", box=None, pad_edge=False)
+        table.add_column("#", justify="right", width=3)
+        table.add_column("Installer", style="green")
+        table.add_column("Description", style="dim", overflow="fold")
+        for i, name in enumerate(sample_names, 1):
+            table.add_row(f"[cyan]{i}[/cyan]", name, name_to_doc.get(name, ""))
+        console.print(table)
+        if len(all_names) > 10:
+            console.print(f"   [dim]... and {len(all_names) - 10} more[/dim]")
+
+    panel = Panel(f"[bold blue]💡 Use 'ia' to interactively browse all available installers.[/bold blue]\n[bold blue]💡 Use one of the categories: {list(PACKAGE_GROUP2NAMES.keys())}[/bold blue]", title="[yellow]Helpful Tips[/yellow]", border_style="yellow")
+    console.print(panel)
+
+
+def install_deb_package(downloaded: Path) -> None:
+    from rich import print as rprint
+    from rich.panel import Panel
+    print(f"📦 Installing .deb package: {downloaded}")
+    import platform
+    import subprocess
+    assert platform.system() == "Linux"
+    result = subprocess.run(f"sudo nala install -y {downloaded}", shell=True, capture_output=True, text=True)
+    success = result.returncode == 0 and result.stderr == ""
+    if not success:
+        from rich.console import Group
+        desc = "Installing .deb"
+        sub_panels = []
+        if result.stdout:
+            sub_panels.append(Panel(result.stdout, title="STDOUT", style="blue"))
+        if result.stderr:
+            sub_panels.append(Panel(result.stderr, title="STDERR", style="red"))
+        group_content = Group(f"❌ {desc} failed\nReturn code: {result.returncode}", *sub_panels)
+        rprint(Panel(group_content, title=desc, style="red"))
+    print("🗑️  Cleaning up .deb package...")
+    if downloaded.is_file():
+        downloaded.unlink(missing_ok=True)
+    elif downloaded.is_dir():
+        import shutil
+        shutil.rmtree(downloaded, ignore_errors=True)

machineconfig/utils/installer_utils/installer_runner.py

@@ -92,7 +92,11 @@ def get_installed_cli_apps():
 
 
 def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: Optional[list[str]]) -> list[InstallerData]:
-    res_all = get_all_installer_data_files()
+    import machineconfig.jobs.installer as module
+    from pathlib import Path
+    res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
+    res_all: list[InstallerData] = res_raw["installers"]
+
     acceptable_apps_names: list[str] | None = None
     if which_cats is not None:
         acceptable_apps_names = []
@@ -116,13 +120,6 @@ def get_installers(os: OPERATING_SYSTEMS, arch: CPU_ARCHITECTURES, which_cats: O
     return all_installers
 
 
-def get_all_installer_data_files() -> list[InstallerData]:
-    import machineconfig.jobs.installer as module
-    from pathlib import Path
-    res_raw: InstallerDataFiles = read_json(Path(module.__file__).parent.joinpath("installer_data.json"))
-    res_final: list[InstallerData] = res_raw["installers"]
-    return res_final
-
 
 def install_bulk(installers_data: list[InstallerData], safe: bool = False, jobs: int = 10, fresh: bool = False):
     print("🚀 BULK INSTALLATION PROCESS 🚀")

machineconfig/utils/links.py

@@ -164,7 +164,7 @@ def symlink_map(config_file_default_path: PathExtended, self_managed_config_file
                 else:
                     # Files are different, use on_conflict strategy
                     import subprocess
-                    command = f"""delta --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
+                    command = f"""delta  --paging never --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
                     try:
                         console.print(Panel(f"🆘 CONFLICT DETECTED | Showing diff between {config_file_default_path} and {self_managed_config_file_path}", title="Conflict Detected", expand=False))
                         subprocess.run(command, shell=True, check=True)
@@ -293,7 +293,7 @@ def copy_map(config_file_default_path: PathExtended, self_managed_config_file_pa
                 else:
                     # Files are different, use on_conflict strategy
                     import subprocess
-                    command = f"""delta --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
+                    command = f"""delta  --paging never --side-by-side "{config_file_default_path}" "{self_managed_config_file_path}" """
                     try:
                         console.print(Panel(f"🆘 CONFLICT DETECTED | Showing diff between {config_file_default_path} and {self_managed_config_file_path}", title="Conflict Detected", expand=False))
                         subprocess.run(command, shell=True, check=True)

machineconfig/utils/meta.py

@@ -29,7 +29,8 @@ except (ImportError, ModuleNotFoundError) as ex:
     return txt
 
 
-def lambda_to_python_script(lmb: Callable[[], Any], in_global: bool, import_module: bool) -> str:
+def lambda_to_python_script(lmb: Callable[[], Any],
+            in_global: bool, import_module: bool) -> str:
     """
     caveats: always use keyword arguments in the lambda call for best results.
     return statement not allowed in the wrapped function (otherwise it can be put in the global space)
@@ -250,7 +251,6 @@ if __name__ == "__main__":
     import_code_robust = "<import_code_robust>"
     res = lambda_to_python_script(
             lambda: print_code(code=import_code_robust, lexer="python", desc="import as module code"),
-            # in_global=True, import_module=False
             in_global=True, import_module=False
         )
     print(res)

machineconfig/utils/options.py

@@ -14,10 +14,10 @@ from typing import Optional, Union, Iterable, overload, Literal, cast
 
 
 @overload
-def choose_from_options[T](msg: str, options: Iterable[T], multi: Literal[False], custom_input: bool = False, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False) -> T: ...
+def choose_from_options[T](options: Iterable[T], msg: str, multi: Literal[False], custom_input: bool = False, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False) -> T: ...
 @overload
-def choose_from_options[T](msg: str, options: Iterable[T], multi: Literal[True], custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> list[T]: ...
-def choose_from_options[T](msg: str, options: Iterable[T], multi: bool, custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> Union[T, list[T]]:
+def choose_from_options[T](options: Iterable[T], msg: str, multi: Literal[True], custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> list[T]: ...
+def choose_from_options[T](options: Iterable[T], msg: str, multi: bool, custom_input: bool = True, header: str = "", tail: str = "", prompt: str = "", default: Optional[T] = None, fzf: bool = False, ) -> Union[T, list[T]]:
     # TODO: replace with https://github.com/tmbo/questionary
     # # also see https://github.com/charmbracelet/gum
     options_strings: list[str] = [str(x) for x in options]

machineconfig/utils/path_extended.py

@@ -711,7 +711,7 @@ class PathExtended(type(Path()), Path):  # type: ignore # pylint: disable=E0241
                 :return: pathlib.Path pointing to the destination directory where contents were extracted
                 :raises: FileNotFoundError if archive does not exist; py7zr.Bad7zFile or other error if extraction fails
                 """
-                import py7zr
+                import py7zr  # type: ignore
                 import tempfile
                 from pathlib import Path
                 archive_path_obj = Path(archive_path)

machineconfig/utils/path_helper.py

@@ -1,4 +1,3 @@
-# from machineconfig.utils.path_extended import Path
 from machineconfig.utils.source_of_truth import EXCLUDE_DIRS
 from rich.console import Console
 from rich.panel import Panel