machineconfig 6.82__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/utils/accessories.py

@@ -1,4 +1,3 @@
-from pathlib import Path
 from typing import Optional, Any
 
 from datetime import datetime, timezone, timedelta
@@ -96,14 +95,42 @@ def human_friendly_dict(d: dict[str, Any]) -> dict[str, Any]:
     return result
 
 
-def get_repo_root(path: Path) -> Optional[Path]:
+def get_repo_root(path: "Path") -> Optional["Path"]:
     from git import Repo, InvalidGitRepositoryError
-
     try:
-        repo = Repo(str(path), search_parent_directories=True)
+        repo = Repo(path, search_parent_directories=True)
         root = repo.working_tree_dir
         if root is not None:
+            from pathlib import Path
             return Path(root)
     except InvalidGitRepositoryError:
         pass
     return None
+
+
+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

@@ -1,48 +1,89 @@
 
-from typing import Any, Optional, Callable
+from typing import Any, Literal, Optional, Callable, cast
 from machineconfig.utils.accessories import randstr
-from machineconfig.utils.meta import lambda_to_python_script
 from pathlib import Path
 
 
+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" """
+        case "Linux" | "linux" | "Darwin" | "darwin" | "macos":
+            return """$HOME/.local/bin/uv """
+        case _:
+            return """$HOME/.local/bin/uv """
+
 def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
     import platform
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.syntax import Syntax
-    if lexer == "shell":
-        if platform.system() == "Windows":
-            lexer = "powershell"
-        elif platform.system() in ["Linux", "Darwin"]:
-            lexer = "sh"
-        else:
-            raise NotImplementedError(f"Platform {platform.system()} not supported for lexer {lexer}")
-    console = Console()
-    console.print(Panel(Syntax(code=code, lexer=lexer), title=f"📄 {desc}", subtitle=subtitle), style="bold red")
+    try:
+        from rich.console import Console
+        from rich.panel import Panel
+        from rich.syntax import Syntax
+        if lexer == "shell":
+            if platform.system() == "Windows":
+                lexer = "powershell"
+            elif platform.system() in ["Linux", "Darwin"]:
+                lexer = "sh"
+            else:
+                raise NotImplementedError(f"Platform {platform.system()} not supported for lexer {lexer}")
+        console = Console()
+        console.print(Panel(Syntax(code=code, lexer=lexer), title=f"📄 {desc}", subtitle=subtitle), style="bold red")
+    except ImportError:
+        print(f"--- {desc} ---")
+        print(code)
+        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]) -> tuple[str, Path]:
-    python_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", randstr() + ".py")
-    python_file.parent.mkdir(parents=True, exist_ok=True)
+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:
-        uv_with.append("rich")
+        if prepend_print: uv_with.append("rich")
         uv_with_arg = "--with " + '"' + ",".join(uv_with) + '"'
     else:
-        uv_with_arg = "--with rich"
+        if prepend_print:
+            uv_with_arg = "--with rich"
+        else:
+            uv_with_arg = ""
     if uv_project_dir is not None:
         uv_project_dir_arg = "--project" + f' "{uv_project_dir}"'
     else:
-        uv_project_dir_arg = ""
-    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")
-    shell_script = f"""uv run {uv_with_arg} {uv_project_dir_arg}  {str(python_file)} """
+        uv_project_dir_arg = "--no-project"
+    import platform
+
+    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 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)
+    return uv_command, py_file
 def run_lambda_function(lmb: Callable[[], Any], uv_with: Optional[list[str]], uv_project_dir: Optional[str]) -> None:
-    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)
-    run_shell_script(uv_command)
+    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, display_script=True, clean_env=False)
+
+
 def run_python_script_in_marimo(py_script: str, uv_project_with: Optional[str]):
     tmp_dir = Path.home().joinpath("tmp_results", "tmp_scripts", "marimo", randstr())
     tmp_dir.mkdir(parents=True, exist_ok=True)
@@ -51,7 +92,7 @@ def run_python_script_in_marimo(py_script: str, uv_project_with: Optional[str]):
     if uv_project_with is not None:
         requirements = f"""--with "marimo" --project {uv_project_with} """
     else:
-        requirements = f"""--with "marimo" """
+        requirements = """--with "marimo" """
     fire_line = f"""
 cd {tmp_dir}
 uv run {requirements} marimo convert {pyfile.name} -o marimo_nb.py
@@ -62,53 +103,124 @@ uv run  {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
     exit_then_run_shell_script(fire_line)
 
 
-def run_shell_script(script: str, display_script: bool = True, clean_env: bool = False):
-    import tempfile
+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, clean_env: bool):
     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_script_path = Path(temp_file.name)
+        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_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_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_script_path)}", check=True, shell=True, env=env)
-    else:
-        raise NotImplementedError(f"Platform {platform.system()} not supported.")
+        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:
-        console.print(f"❌  [red]Script execution failed with return code {proc.returncode}:[/red] [blue]{temp_script_path}[/blue]")
+        console.print(f"❌  [red]Script execution failed with return code {proc.returncode}:[/red] [blue]{temp_shell_script_path}[/blue]")
     elif proc.returncode == 0:
-        console.print(f"✅  [green]Script executed successfully:[/green] [blue]{temp_script_path}[/blue]")
+        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_script_path}[/blue]")    
-    temp_script_path.unlink(missing_ok=True)
-    console.print(f"🗑️  [blue]Temporary script deleted:[/blue] [green]{temp_script_path}[/green]")
+        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
 
 
-def exit_then_run_shell_script(script: str):
+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:
+        exists = Path(op_program_path).exists()
+    else:
+        exists = False
+    # three cases: (op_program_path is None, exists=False), (op_program_path is set, exists=False), (op_program_path is set, exists=True)
+
+    if strict:  # we want to assert op_program_path is set and is not an already existing file
+        if (op_program_path is None or exists):
+            import platform
+            if platform.system() == "Windows":
+                suffix = ".ps1"
+                lexer = "powershell"
+            else:
+                suffix = ".sh"
+                lexer = "bash"
+            op_program_path = Path.home().joinpath("tmp_results", "tmp_scripts", "manual_run", f"manual_script_{randstr()}{suffix}")
+            op_program_path.parent.mkdir(parents=True, exist_ok=True)
+            op_program_path.write_text(script, encoding="utf-8")
+            print_code(code=script, lexer=lexer, desc="script to run manually")
+            console.print("[bold yellow]⚠️  STRICT MODE:[/bold yellow] [cyan]Please run the script manually via your shell by executing:[/cyan]")
+            console.print(f"[green]{str(op_program_path)}[/green]")
+            console.print("[red]❌ OP_PROGRAM_PATH environment variable is not set in strict mode.[/red]")
+            import sys
+            sys.exit(1)
+
+    if op_program_path is not None and not exists:
         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")
+        console.print("[cyan]🚀 Handing over to shell script runner via OP_PROGRAM_PATH:[/cyan]")
+        console.print(f"[bold green]{str(op_program_path)}[/bold green]")
+        print_code(code=script, lexer="shell", desc="script to run via OP_PROGRAM_PATH")
     else:
-        run_shell_script(script)
+        if op_program_path is not None and exists:
+            console.print(f"[yellow]⚠️  OP_PROGRAM_PATH @ {str(op_program_path)} already exists.[/yellow] [cyan]Falling back to direct execution.[/cyan]")
+        elif op_program_path is None:
+            console.print("[cyan]ℹ️  OP_PROGRAM_PATH is not set.[/cyan] [yellow]Falling back to direct execution.[/yellow]")
+        run_shell_script(script, display_script=True, clean_env=False)
+    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,23 +51,23 @@ 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:
             comment = subprocess.run("fortune", shell=True, capture_output=True, text=True, check=True).stdout
         except Exception:
-            comment = "crocodile"
+            comment = "machineconfig"
     if artlib is None: artlib = random.choice(['boxes', 'cowsay'])
     to_file = '' if not file else f'> {file}'
     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

@@ -25,8 +25,9 @@ def print_header():
     table.add_row("Virtual Environment", os.getenv('VIRTUAL_ENV', 'None'))
     table.add_row("Running @", str(Path.cwd()))
 
+    from machineconfig.utils.installer_utils.installer_runner import get_machineconfig_version
 
-    console.print(Panel(table, title="[bold blue]✨ 🐊 Crocodile Shell 14.5 ✨ Made with 🐍 | Built with ❤️[/bold blue]", border_style="blue"))
+    console.print(Panel(table, title=f"[bold blue]✨ 🐊 Machineconfig Shell {get_machineconfig_version()} ✨ Made with 🐍 | Built with ❤️[/bold blue]", border_style="blue"))
 def print_logo(logo: str):
     from machineconfig.utils.files.ascii_art import font_box_color, character_color, character_or_box_color
     if platform.system() == "Windows":
@@ -43,9 +44,9 @@ def print_logo(logo: str):
             _default_art = Path(random.choice(glob.glob(str(Path(__file__).parent.joinpath("art", "*")))))
             print(_default_art.read_text())
     elif platform.system() in ["Linux", "Darwin"]:  # Explicitly handle both Linux and macOS
-        from machineconfig.utils.installer_utils.installer_abc import is_executable_in_path
+        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:
@@ -55,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"