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

machineconfig/type_hinting/typedict/polars_schema.py

@@ -0,0 +1,24 @@
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    import polars as pl
+
+
+def get_polars_schema(typed_dict: type) -> "dict[str, pl.DataType]":
+    import polars as pl
+
+    def _get_polars_type(python_type: Any) -> pl.DataType:
+        if python_type == str:
+            return pl.String()
+        if python_type == float:
+            return pl.Float64()
+        if python_type == int:
+            return pl.Int64()
+        if python_type == bool:
+            return pl.Boolean()
+        return pl.String()
+
+    schema: dict[str, pl.DataType] = {}
+    for k, v in typed_dict.__annotations__.items():
+        schema[k] = _get_polars_type(v)
+    return schema

machineconfig/type_hinting/typedict/polars_schema_typeddict.py

@@ -0,0 +1,63 @@
+from typing import Any, ReadOnly, get_origin, get_args, TYPE_CHECKING
+import random
+import secrets
+
+if TYPE_CHECKING:
+    import polars as pl
+
+
+def _unwrap_type(python_type: Any) -> Any:
+    """Unwrap ReadOnly and other type wrappers to get the inner type."""
+    origin = get_origin(python_type)
+    if origin is ReadOnly:
+        args = get_args(python_type)
+        return args[0] if args else python_type
+    return python_type
+
+
+def _get_polars_type(python_type: Any) -> "pl.DataType":
+    """Convert Python types to appropriate Polars types, handling ReadOnly wrappers."""
+    unwrapped = _unwrap_type(python_type)
+    import polars as pl
+    if unwrapped is str:
+        return pl.String()
+    if unwrapped is float:
+        return pl.Float64()
+    if unwrapped is int:
+        return pl.Int64()
+    if unwrapped is bool:
+        return pl.Boolean()
+    return pl.String()
+
+
+def get_polars_schema_from_typeddict(typed_dict: type) -> dict[str, "pl.DataType"]:
+    """Convert a TypedDict to a Polars schema, properly handling ReadOnly wrappers."""
+    # import polars as pl
+    schema: dict[str, "pl.DataType"] = {}
+    for k, v in typed_dict.__annotations__.items():
+        schema[k] = _get_polars_type(v)
+    return schema
+
+
+def get_polars_df_random_data_from_typeddict(typed_dict: type, n_rows: int) -> "pl.DataFrame":
+    """Generate a Polars DataFrame with random data based on a TypedDict definition."""
+    data: dict[str, "pl.Series"] = {}
+    import polars as pl
+    for k, v in typed_dict.__annotations__.items():
+        unwrapped = _unwrap_type(v)
+        if unwrapped is str:
+            data[k] = pl.Series([secrets.token_hex(8) for _ in range(n_rows)])
+        elif unwrapped is int:
+            data[k] = pl.Series(random.choices(range(-1000, 1000), k=n_rows))
+        elif unwrapped is float:
+            data[k] = pl.Series([random.uniform(-1000.0, 1000.0) for _ in range(n_rows)])
+        elif unwrapped is bool:
+            data[k] = pl.Series(random.choices([True, False], k=n_rows))
+        elif unwrapped is bytes:
+            data[k] = pl.Series([secrets.token_bytes(16) for _ in range(n_rows)])
+        elif get_origin(unwrapped) is list:
+             data[k] = pl.Series([[random.randint(0, 100) for _ in range(3)] for _ in range(n_rows)])
+        else:
+            data[k] = pl.Series([None] * n_rows)
+            
+    return pl.DataFrame(data, schema=get_polars_schema_from_typeddict(typed_dict))

machineconfig/utils/accessories.py

@@ -110,3 +110,27 @@ def get_repo_root(path: "Path") -> Optional["Path"]:
 
 if __name__ == "__main__":
     from pathlib import Path
+
+
+def display_with_flashy_style(msg: str, title: str) -> None:
+    """Display a flashy, unmissable share URL announcement."""
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.text import Text
+    from rich.align import Align
+    console = Console()
+    url_text = Text(msg, style="bold bright_cyan underline")
+    message = Text.assemble(
+        ("🚀 ", "bright_red"),
+        url_text,
+        (" 🚀", "bright_red")
+    )
+    panel = Panel(
+        Align.center(message),
+        title=f"[bold bright_green]🌐 {title} 🌐[/bold bright_green]",
+        subtitle="[italic bright_yellow]⚡ Click the link above to access your shared files! ⚡[/italic bright_yellow]",
+        border_style="bright_magenta",
+        padding=(1, 2),
+        expand=False
+    )
+    console.print(panel)

machineconfig/utils/code.py

@@ -35,7 +35,8 @@ def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
         print(f"--- End of {desc} ---")
 
 
-def get_uv_command_executing_python_file(python_file: str, uv_with: Optional[list[str]], uv_project_dir: Optional[str], 
+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:
@@ -49,7 +50,7 @@ def get_uv_command_executing_python_file(python_file: str, uv_with: Optional[lis
     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_command = get_uv_command(platform=platform.system())
@@ -72,11 +73,14 @@ def get_uv_command_executing_python_script(python_script: str, uv_with: Optional
     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)
 
 
@@ -111,10 +115,7 @@ def run_shell_file(script_path: str, clean_env: bool):
     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) -> Any:
-
+def run_shell_script(script: str, display_script: bool = True, clean_env: bool = False):
     import platform
     if platform.system() == "Windows":
         suffix = ".ps1"
@@ -122,12 +123,10 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
     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
@@ -135,7 +134,6 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
     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")
-
     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:
@@ -144,7 +142,6 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
         console.print(f"✅  [green]Script executed successfully:[/green] [blue]{temp_shell_script_path}[/blue]")
     else:
         console.print(f"⚠️  [yellow]Script executed with warnings (return code {proc.returncode}):[/yellow] [blue]{temp_shell_script_path}[/blue]")
-
     temp_shell_script_path.unlink(missing_ok=True)
     console.print(f"🗑️  [blue]Temporary script deleted:[/blue] [green]{temp_shell_script_path}[/green]")
     return proc
@@ -153,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:
@@ -196,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)