machineconfig 8.12__py3-none-any.whl → 8.45__py3-none-any.whl

machineconfig/utils/code.py

@@ -4,15 +4,15 @@ from machineconfig.utils.accessories import randstr
 from pathlib import Path
 
 
-def get_uv_run_command(platform: str) -> str:
+def get_uv_command(platform: str) -> str:
     res = cast(Literal["Windows", "windows", "nt", "Linux", "linux", "Darwin", "darwin", "macos"], platform)
     match res:
         case "Windows" | "windows" | "nt":
-            return """& "$env:USERPROFILE/.local/bin/uv" run"""
+            return """& "$env:USERPROFILE/.local/bin/uv" """
         case "Linux" | "linux" | "Darwin" | "darwin" | "macos":
-            return """$HOME/.local/bin/uv run"""
+            return """$HOME/.local/bin/uv """
         case _:
-            return """$HOME/.local/bin/uv run"""
+            return """$HOME/.local/bin/uv """
 
 def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
     import platform
@@ -35,19 +35,9 @@ def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
         print(f"--- End of {desc} ---")
 
 
-def get_uv_command_executing_python_script(python_script: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str],
-                                           prepend_print: bool = True) -> tuple[str, Path]:
-    # python file
-    python_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", randstr() + ".py")
-    python_file.parent.mkdir(parents=True, exist_ok=True)
-    if prepend_print:
-        from machineconfig.utils.meta import lambda_to_python_script
-        print_code_string = lambda_to_python_script(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"),
-                                                    in_global=True, import_module=False)
-        python_file.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
-    else:
-        python_file.write_text(python_script, encoding="utf-8")
-
+def get_uv_command_executing_python_file(python_file: str, uv_with: Optional[list[str]],
+                                         uv_project_dir: Optional[str],
+                                        prepend_print: bool = True, ) -> str:
     # shell script
     if uv_with is not None and len(uv_with) > 0:
         if prepend_print: uv_with.append("rich")
@@ -60,19 +50,37 @@ def get_uv_command_executing_python_script(python_script: str, uv_with: Optional
     if uv_project_dir is not None:
         uv_project_dir_arg = "--project" + f' "{uv_project_dir}"'
     else:
-        uv_project_dir_arg = ""
+        uv_project_dir_arg = "--no-project"
     import platform
-    uv_run = get_uv_run_command(platform=platform.system())
-    shell_script = f"""{uv_run} {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
 
+    uv_command = get_uv_command(platform=platform.system())
+    shell_script = f"""{uv_command} run {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
+    return shell_script
+
+
+def get_uv_command_executing_python_script(python_script: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str],
+                                           prepend_print: bool = True, ) -> tuple[str, Path]:
+    python_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", randstr() + ".py")
+    python_file.parent.mkdir(parents=True, exist_ok=True)
+    if prepend_print:
+        from machineconfig.utils.meta import lambda_to_python_script
+        print_code_string = lambda_to_python_script(lambda: print_code(code=python_script, lexer="python", desc="Temporary Python Script", subtitle="Executing via shell script"),
+                                                    in_global=True, import_module=False)
+        python_file.write_text(print_code_string + "\n" + python_script, encoding="utf-8")
+    else:
+        python_file.write_text(python_script, encoding="utf-8")
+    shell_script = get_uv_command_executing_python_file(python_file=str(python_file), uv_with=uv_with, uv_project_dir=uv_project_dir, prepend_print=prepend_print)
     return shell_script, python_file
 
 
-def run_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> None:
+def get_shell_script_running_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> tuple[str, Path]:
     from machineconfig.utils.meta import lambda_to_python_script
     code = lambda_to_python_script(lmb,
                                             in_global=True, import_module=False)
-    uv_command, _py_file = get_uv_command_executing_python_script(python_script=code, uv_with=uv_with, uv_project_dir=uv_project_dir)
+    uv_command, py_file = get_uv_command_executing_python_script(python_script=code, uv_with=uv_with, uv_project_dir=uv_project_dir)
+    return uv_command, py_file
+def run_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> None:
+    uv_command, _py_file = get_shell_script_running_lambda_function(lmb=lmb, uv_with=uv_with, uv_project_dir=uv_project_dir)
     run_shell_script(uv_command)
 
 
@@ -95,35 +103,38 @@ uv run  {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
     exit_then_run_shell_script(fire_line)
 
 
+def run_shell_file(script_path: str, clean_env: bool):
+    import platform
+    env = {} if clean_env else None
+    if platform.system() == "Windows":
+        import subprocess
+        proc = subprocess.run(f'powershell -ExecutionPolicy Bypass -File "{script_path}"', check=True, shell=True, env=env)
+    elif platform.system() == "Linux" or platform.system() == "Darwin":
+        import subprocess
+        proc = subprocess.run(f"bash {str(script_path)}", check=True, shell=True, env=env)
+    else:
+        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    return proc
 def run_shell_script(script: str, display_script: bool = True, clean_env: bool = False):
-    import tempfile
     import platform
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.syntax import Syntax
-
     if platform.system() == "Windows":
         suffix = ".ps1"
         lexer = "powershell"
     else:
         suffix = ".sh"
         lexer = "bash"
+    import tempfile
     with tempfile.NamedTemporaryFile(mode='w', suffix=suffix, delete=False, encoding='utf-8') as temp_file:
         temp_file.write(script)
         temp_shell_script_path = Path(temp_file.name)
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+    from rich.console import Console
     console = Console()
     if display_script:
         from rich.syntax import Syntax
         console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 shell script @ {temp_shell_script_path}", subtitle="shell script being executed"), style="bold red")
-    env = {} if clean_env else None
-    if platform.system() == "Windows":
-        import subprocess
-        proc = subprocess.run(f'powershell -ExecutionPolicy Bypass -File "{temp_shell_script_path}"', check=True, shell=True, env=env)
-    elif platform.system() == "Linux" or platform.system() == "Darwin":
-        import subprocess
-        proc = subprocess.run(f"bash {str(temp_shell_script_path)}", check=True, shell=True, env=env)
-    else:
-        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    proc = run_shell_file(script_path=str(temp_shell_script_path), clean_env=clean_env)
     # console.print(f"✅  [green]Script executed successfully:[/green] [blue]{temp_script_path}[/blue]")
     if proc.returncode != 0:
         console.print(f"❌  [red]Script execution failed with return code {proc.returncode}:[/red] [blue]{temp_shell_script_path}[/blue]")
@@ -139,7 +150,6 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
 def exit_then_run_shell_script(script: str, strict: bool = False):
     import os
     from rich.console import Console
-    
     console = Console()
     op_program_path = os.environ.get("OP_PROGRAM_PATH", None)
     if op_program_path is not None:
@@ -182,3 +192,35 @@ def exit_then_run_shell_script(script: str, strict: bool = False):
         run_shell_script(script)
     import sys
     sys.exit(0)
+def exit_then_run_shell_file(script_path: str, strict: bool):
+    import os
+    from rich.console import Console
+    console = Console()
+    op_program_path = os.environ.get("OP_PROGRAM_PATH", None)
+    if op_program_path is None or Path(op_program_path).exists():
+        if strict:
+            console.print("[red]❌ OP_PROGRAM_PATH environment variable is not set or the file already exists in strict mode.[/red]")
+            import sys
+            sys.exit(1)
+    if op_program_path is None or Path(op_program_path).exists():
+        console.print("[cyan]ℹ️  OP_PROGRAM_PATH is not set.[/cyan] [yellow]Falling back to direct execution.[/yellow]")
+        run_shell_file(script_path=script_path, clean_env=False)
+        return
+    import platform
+    if platform.system() == "Windows":
+        suffix = ".ps1"
+        lexer = "powershell"
+        script = str(script_path)
+    elif platform.system() == "Linux" or platform.system() == "Darwin":
+        suffix = ".sh"
+        lexer = "bash"
+        script = f"source {str(script_path)}"
+    else:
+        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+    op_program_path = Path(op_program_path)
+    op_program_path.parent.mkdir(parents=True, exist_ok=True)
+    op_program_path.write_text(script, encoding="utf-8")
+    _ = suffix, lexer
+    console.print(f"[cyan]🚀 Handing over to shell script runner via OP_PROGRAM_PATH @ {str(op_program_path)}[/cyan]")
+    import sys
+    sys.exit(0)

machineconfig/utils/files/ascii_art.py

@@ -32,15 +32,11 @@ class BoxStyles:
 
 class CowStyles:
     eyes = ['-b', '-d', '-g', '-h', '-l', '-L', '-n', '-N', '-p', '-s', '-t', '-w', '-y']
-    # this one for the package installed with sudo apt install cowsay and is located at /usr/games/cowsay. See cowsay -l
-    figures = ['apt', 'bunny', 'cheese', 'cock', 'cower', 'daemon', 'default', 'dragon',
-               'dragon-and-cow', 'duck', 'elephant', 'elephant-in-snake', 'eyes', 'fox', 'ghostbusters',
-               'gnu', 'kangaroo', 'kiss', 'milk',
-               'moose', 'pony', 'pony-smaller', 'sheep', 'skeleton', 'snowman', 'stegosaurus',  # 'suse',
-               'three-eyes', 'turkey', 'turtle', 'tux', 'unipony', 'unipony-smaller', 'vader', 'vader']  # 'hellokitty' 'mech-and-cow'  # 'moofasa', 'stimpy', 'calvin', , 'ren', 'koala', 'flaming-sheep' , 'bud-frogs' , 'kosh' , 'luke-koala'
+    # Available characters from Python cowsay package (uv tool install cowsay)
+    figures = ['beavis', 'cheese', 'cow', 'daemon', 'dragon', 'fox', 'ghostbusters', 'kitty', 'meow', 'miki', 'milk', 'octopus', 'pig', 'stegosaurus', 'stimpy', 'trex', 'turkey', 'turtle', 'tux']
 
 
-FIGLET_FONTS = ['banner', 'big', 'standard']
+FIGLET_FONTS = ['Banner', 'Big', 'Standard']
 
 FIGJS_FONTS = ['3D Diagonal', '3D-ASCII', '4Max', '5 Line Oblique', 'Acrobatic', 'ANSI Regular', 'ANSI Shadow',
                'Avatar', 'Banner', 'Banner3-D', 'Banner4',
@@ -55,8 +51,8 @@ FIGJS_FONTS = ['3D Diagonal', '3D-ASCII', '4Max', '5 Line Oblique', 'Acrobatic',
 
 def get_art(comment: Optional[str] = None, artlib: Optional[BOX_OR_CHAR] = None, style: Optional[str] = None, super_style: str = 'scene', prefix: str = ' ', file: Optional[str] = None, verbose: bool = True):
     """ takes in a comment and does the following wrangling:
-    * text => figlet font => boxes => lolcat
-    * text => cowsay => lolcat
+    * text => figlet font => boxes => lolcatjs
+    * text => cowsay => lolcatjs
     """
     if comment is None:
         try:
@@ -68,10 +64,10 @@ def get_art(comment: Optional[str] = None, artlib: Optional[BOX_OR_CHAR] = None,
     if artlib == 'boxes':
         if style is None: style = random.choice(BoxStyles.__dict__[super_style or random.choice(['language', 'scene', 'character'])])
         fonting = f'figlet -f {random.choice(FIGLET_FONTS)}'
-        cmd = f"""echo "{comment}" | {fonting} | boxes -d {style} {to_file}"""
+        cmd = f"""{fonting} "{comment}" | boxes -d {style} {to_file}"""
     else:
         if style is None: style = random.choice(CowStyles.figures)
-        cmd = f"""echo "{comment}" | /usr/games/cowsay -f {style} {to_file}"""
+        cmd = f"""cowsay -c {style} -t "{comment}" {to_file}"""
     try:
         res = subprocess.run(cmd, text=True, capture_output=True, shell=True, check=True).stdout
     except subprocess.CalledProcessError as ex:
@@ -91,7 +87,7 @@ def font_box_color(logo: str):
     box_style = random.choice(['whirly', 'xes', 'columns', 'parchment', 'scroll', 'scroll-akn', 'diamonds', 'headline', 'nuke', 'spring', 'stark1'])
     _cmd = f'figlet -f "{font}" "{logo}" | boxes -d "{box_style}" | lolcatjs'
     # print(_cmd)
-    os.system(_cmd)  # | lolcat
+    os.system(_cmd)  # | lolcatjs
     # print("after")
 
 
@@ -100,7 +96,7 @@ def character_color(logo: str):
     with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
         f.write(ArtLib.cowsay(logo))
         _new_art = f.name
-    os.system(f'type {_new_art} | lolcatjs')  # | lolcat
+    os.system(f'type {_new_art} | lolcatjs')  # | lolcatjs
 
 
 def character_or_box_color(logo: str):
@@ -110,7 +106,7 @@ def character_or_box_color(logo: str):
     get_art(logo, artlib=None, file=_new_art, verbose=False)
     # Prefer bat on mac if available, fallback to cat
     pager = "bat" if (platform.system() == "Darwin" and any((Path(p).joinpath("bat").exists() for p in os.environ.get("PATH", "").split(os.pathsep)))) else "cat"
-    command = f"{pager} {_new_art} | lolcat"
+    command = f"{pager} {_new_art} | lolcatjs"
     os.system(command)
 
 

machineconfig/utils/files/headers.py

@@ -46,7 +46,7 @@ def print_logo(logo: str):
     elif platform.system() in ["Linux", "Darwin"]:  # Explicitly handle both Linux and macOS
         from machineconfig.utils.installer_utils.installer_locator_utils import is_executable_in_path
         avail_cowsay = is_executable_in_path("cowsay")
-        avail_lolcat = is_executable_in_path("lolcat")
+        avail_lolcat = is_executable_in_path("lolcatjs")
         avail_boxes = is_executable_in_path("boxes")
         avail_figlet = is_executable_in_path("figlet")
         if avail_cowsay and avail_lolcat and avail_boxes and avail_figlet:
@@ -56,10 +56,8 @@ def print_logo(logo: str):
             #     print(Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*"))))).read_text())
             character_or_box_color(logo=logo)
         else:
-            print("\n" + "🚫 " + "-" * 70 + " 🚫")
-            install_cmd = "devops install --group TerminalEyeCandy" if platform.system() == "Linux" else "brew install cowsay lolcat boxes figlet"
-            print(f"🔍 Missing ASCII art dependencies. Install with: {install_cmd}")
-            print("🚫 " + "-" * 70 + " 🚫\n")
+            install_cmd = "devops install --group term-eye-candy "
+            print(f"🔍 Missing ASCII art dependencies. Install with: {install_cmd}  | {avail_boxes=} {avail_cowsay} {avail_figlet} {avail_lolcat=}")
             _default_art = Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*")))))
             print(_default_art.read_text())
     else:

machineconfig/utils/files/read.py

@@ -14,7 +14,11 @@ class Read:
         if suffix in ("sqlite", "sqlite3", "db", "duckdb"):
             from machineconfig.utils.files.dbms import DBMS
             res = DBMS.from_local_db(path=path)
-            print(res.describe_db())
+            try:
+                print(res.describe_db())
+            except Exception:
+                print("💥 Could not describe the database.")
+                pass
             return res
         try: return getattr(Read, suffix)(str(path), **kwargs)
         except AttributeError as err:
@@ -28,6 +32,9 @@ class Read:
             elif suffix == "csv":
                 import polars as pl
                 return pl.read_csv(path, **kwargs)
+            elif suffix == "npz" or suffix == "npy":
+                import numpy as np
+                return np.load(str(path), **kwargs)
             try:
                 # guess = install_n_import('magic', 'python-magic').from_file(path)
                 guess = "IDKm"

machineconfig/utils/installer_utils/github_release_bulk.py

@@ -86,6 +86,7 @@ def fetch_github_release_data(
         response = requests.get(url, timeout=30)
         if response.status_code != 200:
             print(f"❌ Failed to fetch data for {username}/{repo_name}: HTTP {response.status_code}")
+            print(f"   URL: {url}")
             return None
 
         response_data = response.json()

machineconfig/utils/installer_utils/install_from_url.py

@@ -150,7 +150,7 @@ def install_from_github_url(github_url: str) -> None:
         size_padded = item["size_str"].ljust(max_size_len)
         downloads_padded = item["downloads_str"].rjust(max_downloads_len)
         
-        label = f"{name_padded} {size_padded} | ⬇ {downloads_padded} | 📅 {item['date_str']}"
+        label = f"{name_padded} {size_padded} | #🔽 {downloads_padded} | 📅 {item['date_str']}"
         options_map[label] = item["asset"]
     
     if not options_map:

machineconfig/utils/installer_utils/installer_class.py

@@ -13,6 +13,9 @@ import subprocess
 from typing import Optional
 
 
+PACAKGE_MANAGERS = ["bun", "npm", "pip", "uv", "winget", "powershell", "irm", "brew", "curl", "sudo"]
+
+
 class Installer:
     def __init__(self, installer_data: InstallerData):
         self.installer_data: InstallerData = installer_data
@@ -62,8 +65,13 @@ class Installer:
         if installer_arch_os is None:
             raise ValueError(f"No installation pattern for {exe_name} on {os_name} {arch}")
         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 ", "sudo"]):
+
+        package_manager_installer = any(pm in installer_arch_os.split(" ") for pm in PACAKGE_MANAGERS)
+        script_installer = installer_arch_os.endswith((".sh", ".py", ".ps1"))
+        binary_download_link = installer_arch_os.startswith("https://") or installer_arch_os.startswith("http://")
+
+        if (repo_url == "CMD") or package_manager_installer or script_installer or binary_download_link:
+            if package_manager_installer:
                 from rich import print as rprint
                 from rich.panel import Panel
                 from rich.console import Group
@@ -81,7 +89,7 @@ class Installer:
                         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")):
+            elif script_installer:
                 import machineconfig.jobs.installer as module
                 from pathlib import Path
                 search_root = Path(module.__file__).parent
@@ -106,7 +114,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://") or installer_arch_os.startswith("http://"):
+            elif binary_download_link:
                 downloaded_object = download_and_prepare(installer_arch_os)
                 if downloaded_object.suffix in [".exe", ""]:  # likely an executable
                     if platform.system() == "Windows":

machineconfig/utils/installer_utils/installer_cli.py

@@ -1,18 +1,5 @@
-"""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
-
 
+"""Devops Devapps Install
 """
 
 from machineconfig.utils.installer_utils.installer_helper import get_group_name_to_repr
@@ -20,7 +7,6 @@ import typer
 from typing import Annotated, Optional
 
 
-
 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,

machineconfig/utils/installer_utils/installer_helper.py

@@ -104,7 +104,7 @@ def install_deb_package(downloaded: Path) -> None:
 
 def download_and_prepare(download_url: str) -> PathExtended:
     # archive_path = PathExtended(download_url).download(folder=INSTALL_TMP_DIR)
-    from machineconfig.scripts.python.helpers_utils.download import download
+    from machineconfig.scripts.python.helpers.helpers_utils.download import download
     downloaded_object = download(download_url, output_dir=str(INSTALL_TMP_DIR))
     if downloaded_object is None:
         raise ValueError(f"Failed to download from URL: {download_url}")
@@ -121,7 +121,7 @@ def download_and_prepare(download_url: str) -> PathExtended:
                 if nested_path.is_file() and any(ex in nested_path.suffixes for ex in DECOMPRESS_SUPPORTED_FORMATS):
                     extracted_path = nested_path.decompress()
                     nested_path.delete(sure=True)
-    elif extracted_path.is_dir() and len(extracted_path.search("*", r=True)) == 1:
+    elif extracted_path.is_dir() and len([p for p in extracted_path.rglob("*") if not p.name.startswith(".")]) == 1:
         only_file_in = next(extracted_path.glob("*"))
         if only_file_in.is_file() and any(ext in str(only_file_in) for ext in DECOMPRESS_SUPPORTED_FORMATS):  # further decompress
             extracted_path = only_file_in.decompress()

machineconfig/utils/installer_utils/installer_locator_utils.py

@@ -22,15 +22,15 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, tool_name: Opti
     else:
         print(f"🔎 Searching for executable in: {downloaded_file_path}")
         if tool_name is None:
-            exe = downloaded_file_path.search("*.exe", r=True)[0]
+            exe = list(downloaded_file_path.rglob("*.exe"))[0]
             print(f"✅ Found executable: {exe}")
         else:
-            tmp = downloaded_file_path.search(f"{tool_name}.exe", r=True)
+            tmp = list(downloaded_file_path.rglob(f"{tool_name}.exe"))
             if len(tmp) == 1:
                 exe = tmp[0]
                 print(f"✅ Found exact match for {tool_name}.exe: {exe}")
             else:
-                search_res = downloaded_file_path.search("*.exe", r=True)
+                search_res = list(downloaded_file_path.rglob("*.exe"))
                 if len(search_res) == 0:
                     print(f"❌ ERROR: No executable found in {downloaded_file_path}")
                     raise IndexError(f"No executable found in {downloaded_file_path}")
@@ -38,8 +38,8 @@ def find_move_delete_windows(downloaded_file_path: PathExtended, tool_name: Opti
                     exe = search_res[0]
                     print(f"✅ Found single executable: {exe}")
                 else:
-                    exe = max(search_res, key=lambda x: x.size("kb"))
-                    print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
+                    exe = max(search_res, key=lambda x: x.stat().st_size)
+                    print(f"✅ Selected largest executable ({round(exe.stat().st_size / 1024, 1)} KB): {exe}")
         if rename_to and exe.name != rename_to:
             print(f"🏷️  Renaming '{exe.name}' to '{rename_to}'")
             exe = exe.with_name(name=rename_to, inplace=True)
@@ -70,20 +70,20 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: Optional[str], d
         print(f"📄 Found direct executable file: {exe}")
     else:
         print(f"🔎 Searching for executable in: {downloaded}")
-        res = downloaded.search(f"*{tool_name}*", folders=False, r=True)
+        res = [p for p in downloaded.rglob(f"*{tool_name}*") if p.is_file()]
         if len(res) == 1:
             exe = res[0]
             print(f"✅ Found match for pattern '*{tool_name}*': {exe}")
         else:
             if tool_name is None:  # no tool name provided, get the largest executable
-                search_res = downloaded.search("*", folders=False, files=True, r=True)
+                search_res = [p for p in downloaded.rglob("*") if p.is_file()]
                 if len(search_res) == 0:
                     print(f"❌ ERROR: No search results in `{downloaded}`")
                     raise IndexError(f"No executable found in {downloaded}")
-                exe = max(search_res, key=lambda x: x.size("kb"))
-                print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
+                exe = max(search_res, key=lambda x: x.stat().st_size)
+                print(f"✅ Selected largest executable ({round(exe.stat().st_size / 1024, 1)} KB): {exe}")
             else:
-                exe_search_res = downloaded.search(tool_name, folders=False, r=True)
+                exe_search_res = [p for p in downloaded.rglob(tool_name) if p.is_file()]
                 if len(exe_search_res) == 0:
                     print(f"❌ ERROR: No search results for `{tool_name}` in `{downloaded}`")
                     raise IndexError(f"No executable found in {downloaded}")
@@ -91,8 +91,8 @@ def find_move_delete_linux(downloaded: PathExtended, tool_name: Optional[str], d
                     exe = exe_search_res[0]
                     print(f"✅ Found exact match for '{tool_name}': {exe}")
                 else:
-                    exe = max(exe_search_res, key=lambda x: x.size("kb"))
-                    print(f"✅ Selected largest executable ({exe.size('kb')} KB): {exe}")
+                    exe = max(exe_search_res, key=lambda x: x.stat().st_size)
+                    print(f"✅ Selected largest executable ({round(exe.stat().st_size / 1024, 1)} KB): {exe}")
 
     if rename_to and exe.name != rename_to:
         print(f"🏷️  Renaming '{exe.name}' to '{rename_to}'")
@@ -155,7 +155,7 @@ def check_tool_exists(tool_name: str) -> bool:
             version = result.stdout.strip().lstrip('v')
             nvm_bin_path = Path.home() / ".nvm" / "versions" / "node" / f"v{version}" / "bin" / tool_name
             npm_check = nvm_bin_path.is_file()
-        except subprocess.CalledProcessError:
+        except (subprocess.CalledProcessError, FileNotFoundError):
             pass
         return npm_check
     else:

machineconfig/utils/installer_utils/installer_runner.py

@@ -75,18 +75,18 @@ def get_installed_cli_apps():
     print("🔍 LISTING INSTALLED CLI APPS 🔍")
     if platform.system() == "Windows":
         print("🪟 Searching for Windows executables...")
-        apps = PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").search("*.exe", not_in=["notepad"])
+        apps = [p for p in PathExtended.home().joinpath("AppData/Local/Microsoft/WindowsApps").glob("*.exe") if "notepad" not in str(p)]
     elif platform.system() in ["Linux", "Darwin"]:
         print(f"🐧 Searching for {platform.system()} executables...")
         if platform.system() == "Linux":
-            apps = PathExtended(LINUX_INSTALL_PATH).search("*") + PathExtended("/usr/local/bin").search("*")
+            apps = list(PathExtended(LINUX_INSTALL_PATH).glob("*")) + list(PathExtended("/usr/local/bin").glob("*"))
         else:  # Darwin/macOS
-            apps = PathExtended("/usr/local/bin").search("*") + PathExtended("/opt/homebrew/bin").search("*")
+            apps = list(PathExtended("/usr/local/bin").glob("*")) + list(PathExtended("/opt/homebrew/bin").glob("*"))
     else:
         error_msg = f"❌ ERROR: System {platform.system()} not supported"
         print(error_msg)
         raise NotImplementedError(error_msg)
-    apps = [app for app in apps if app.size("kb") > 0.1 and not app.is_symlink()]  # no symlinks like paint and wsl and bash
+    apps = [app for app in apps if (app.stat().st_size / 1024) > 0.1 and not app.is_symlink()]  # no symlinks like paint and wsl and bash
     print(f"✅ Found {len(apps)} installed applications")
     return apps
 

machineconfig/utils/meta.py

@@ -5,7 +5,7 @@ from typing import Any
 
 
 def get_import_module_string(py_file: str) -> str:
-    from machineconfig.scripts.python.helpers_fire_command.file_wrangler import get_import_module_code
+    from machineconfig.scripts.python.helpers.helpers_fire_command.file_wrangler import get_import_module_code
     from machineconfig.utils.accessories import get_repo_root
     from pathlib import Path
     repo_root = get_repo_root(Path(py_file))
@@ -68,7 +68,7 @@ def lambda_to_python_script(lmb: Callable[[], Any],
 
     # sanity checks
     if not (callable(lmb) and isinstance(lmb, _types.LambdaType)):
-        raise TypeError("Expected a lambda function object")
+        raise TypeError(f"Expected a lambda function object, got {type(lmb)}")
 
     src = _inspect.getsource(lmb)
     src = _textwrap.dedent(src)
@@ -81,7 +81,7 @@ def lambda_to_python_script(lmb: Callable[[], Any],
             lambda_node = n
             break
     if lambda_node is None:
-        raise ValueError("Could not find a lambda expression in source")
+        raise ValueError(f"""Could not find a lambda expression in source, got:\n{lmb}\nwhich is not a lambda, its a {src}""")
 
     body = lambda_node.body
     if not isinstance(body, _ast.Call):
@@ -113,7 +113,7 @@ def lambda_to_python_script(lmb: Callable[[], Any],
     if not callable(func_obj):
         raise TypeError("Resolved object is not callable")
 
-    func_name = getattr(func_obj, "__name__", "<unknown>")
+    func_name = getattr(getattr(func_obj, "__code__", None), "co_name", None) or getattr(func_obj, "__name__", "<unknown>")
 
     import_prefix: str = ""
     if import_module:
@@ -249,8 +249,10 @@ def lambda_to_python_script(lmb: Callable[[], Any],
 if __name__ == "__main__":
     from machineconfig.utils.code import print_code
     import_code_robust = "<import_code_robust>"
+    print_code.__name__ = "blah"
     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
         )
+
     print(res)