machineconfig 3.7__py3-none-any.whl → 7.69__py3-none-any.whl

machineconfig/utils/code.py

@@ -1,111 +1,158 @@
-import platform
-from typing import Optional
-import subprocess
-from rich.console import Console
-from rich.panel import Panel
-from rich.syntax import Syntax
 
+from typing import Any, Optional, Callable
 from machineconfig.utils.accessories import randstr
-from machineconfig.utils.ve import get_ve_activate_line
-from machineconfig.utils.path_extended import PathExtended as PathExtended
+from machineconfig.utils.meta import lambda_to_python_script
+from pathlib import Path
 
 
-def get_shell_script_executing_python_file(python_file: str, func: Optional[str], ve_path: str, strict_execution: bool = True):
-    if func is None:
-        exec_line = f"""python {python_file}"""
+def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
+    import platform
+    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)
+    if uv_with is not None and len(uv_with) > 0:
+        uv_with.append("rich")
+        uv_with_arg = "--with " + '"' + ",".join(uv_with) + '"'
     else:
-        exec_line = f"""python -m fire {python_file} {func}"""
-    shell_script = f"""
-echo "Executing `{exec_line}`"
-{get_ve_activate_line(ve_path)}
-{exec_line}
-deactivate || true
-"""
+        uv_with_arg = "--with rich"
+    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)} """
+    return shell_script, python_file
 
-    if strict_execution:
-        if platform.system() == "Windows":
-            shell_script = """$ErrorActionPreference = "Stop" """ + "\n" + shell_script
-        if platform.system() in ["Linux", "Darwin"]:
-            shell_script = "set -e" + "\n" + shell_script
 
-    if platform.system() in ["Linux", "Darwin"]:
-        shell_script = "#!/bin/bash" + "\n" + shell_script  # vs #!/usr/bin/env bash
-    return shell_script
+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)
+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)
+    pyfile = tmp_dir / "marimo_db_explore.py"
+    pyfile.write_text(py_script, encoding="utf-8")
+    if uv_project_with is not None:
+        requirements = f"""--with "marimo" --project {uv_project_with} """
+    else:
+        requirements = """--with "marimo" """
+    fire_line = f"""
+cd {tmp_dir}
+uv run {requirements} marimo convert {pyfile.name} -o marimo_nb.py
+bat marimo_nb.py
+uv run  {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
+"""
+    print_code(code=py_script, desc="Generated Marimo DB Explore Script", lexer="python")
+    exit_then_run_shell_script(fire_line)
 
 
-def get_shell_file_executing_python_script(python_script: str, ve_path: str, verbose: bool = True):
-    if verbose:
-        python_script = (
-            f"""
-code = r'''{python_script}''' """
-            + """
-try:
-    from machineconfig.utils.utils import print_code
-    print_code(code=code, lexer="python", desc="Python Script")
-except ImportError:
+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
-    console = Console()
-    console.print(Panel(f'''📜 PYTHON SCRIPT:\n\n{{code}}''', title="Python Script", expand=False))
-"""
-            + python_script
-        )
-    python_file = PathExtended.tmp().joinpath("tmp_scripts", "python", randstr() + ".py")
-    python_file.parent.mkdir(parents=True, exist_ok=True)
-    python_file.write_text(python_script, encoding="utf-8")
-    shell_script = get_shell_script_executing_python_file(python_file=str(python_file), func=None, ve_path=ve_path)
-    shell_file = write_shell_script_to_file(shell_script)
-    return shell_file
-
+    from rich.syntax import Syntax
 
-def write_shell_script_to_file(shell_script: str):
-    if platform.system() in ["Linux", "Darwin"]:
-        suffix = ".sh"
-    elif platform.system() == "Windows":
+    if platform.system() == "Windows":
         suffix = ".ps1"
+        lexer = "powershell"
     else:
-        raise NotImplementedError(f"Platform {platform.system()} not implemented.")
-    shell_file = PathExtended.tmp().joinpath("tmp_scripts", "shell", randstr() + suffix)
-    shell_file.parent.mkdir(parents=True, exist_ok=True)
-    shell_file.write_text(shell_script, encoding="utf-8")
-    return shell_file
-
-
-# Enhanced print/log/error/exception statements for better clarity and consistency
-# Improved formatting and language of messages
-# Ensured consistent use of f-strings with triple quotes where applicable
+        suffix = ".sh"
+        lexer = "bash"
+    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)
+    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.")
+    # 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]")
+    elif proc.returncode == 0:
+        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
 
 
-def write_shell_script_to_default_program_path(program: str, desc: str, preserve_cwd: bool, display: bool, execute: bool):
-    if preserve_cwd:
-        if platform.system() == "Windows":
-            program = "$orig_path = $pwd\n" + program + "\ncd $orig_path"
-        else:
-            program = 'orig_path=$(cd -- "." && pwd)\n' + program + '\ncd "$orig_path" || exit'
-    if display:
-        print_code(code=program, lexer="shell", desc=desc, subtitle="PROGRAM")
-    # PROGRAM_PATH.parent.mkdir(parents=True, exist_ok=True)
-    # PROGRAM_PATH.write_text(program, encoding="utf-8")
-    if execute:
-        result = subprocess.run(program, shell=True, capture_output=True, text=True)
-        success = result.returncode == 0 and result.stderr == ""
-        if not success:
-            print("❌ 🛠️  EXECUTION | Shell script running failed")
-            if result.stdout:
-                print(f"STDOUT: {result.stdout}")
-            if result.stderr:
-                print(f"STDERR: {result.stderr}")
-            print(f"Return code: {result.returncode}")
-    return None
+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)
 
-def print_code(code: str, lexer: str, desc: str, subtitle: str = ""):
-    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")
+    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:
+        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)
+    import sys
+    sys.exit(0)

machineconfig/utils/files/art/fat_croco.txt

@@ -0,0 +1,10 @@
+                _ ___                /^^\ /^\  /^^\_
+    _          _@)@) \            ,,/ '` ~ `'~~ ', `\.
+  _/o\_ _ _ _/~`.`...'~\        ./~~..,'`','',.,' '  ~:
+ / `,'.~,~.~  .   , . , ~|,   ,/ .,' , ,. .. ,,.   `,  ~\_
+( ' _' _ '_` _  '  .    , `\_/ .' ..' '  `  `   `..  `,   \_
+ ~V~ V~ V~ V~ ~\ `   ' .  '    , ' .,.,''`.,.''`.,.``. ',   \_
+  _/\ /\ /\ /\_/, . ' ,   `_/~\_ .' .,. ,, , _/~\_ `. `. '.,  \_
+ < ~ ~ '~`'~'`, .,  .   `_: ::: \_ '      `_/ ::: \_ `.,' . ',  \_
+  \ ' `_  '`_    _    ',/ _::_::_ \ _    _/ _::_::_ \   `.,'.,`., \-,-,-,_,_,
+   `'~~ `'~~ `'~~ `'~~  \(_)(_)(_)/  `~~' \(_)(_)(_)/ ~'`\_.._,._,'_;_;_;_;_;

machineconfig/utils/files/art/halfwit_croco.txt

@@ -0,0 +1,9 @@
+                    .-._   _ _ _ _ _ _ _ _
+         .-''-.__.-'00  '-' ' ' ' ' ' ' ' '-.
+         '.___ '    .   .--_'-' '-' '-' _'-' '._
+          V: V 'vv-'   '_   '.       .'  _..' '.'.
+            '=.____.=_.--'   :_.__.__:_   '.   : :
+                    (((____.-'        '-.  /   : :
+                                      (((-'\ .' /
+                                    _____..'  .'
+                                   '-._____.-'

machineconfig/utils/files/art/happy_croco.txt

@@ -0,0 +1,22 @@
+                          .--.  .--.
+                         /    \/    \
+                        | .-.  .-.   \
+                        |/_  |/_  |   \
+                        || `\|| `\|    `----.
+                        |\0_/ \0_/    --,    \_
+      .--"""""-.       /              (` \     `-.
+     /          \-----'-.              \          \
+     \  () ()                         /`\          \
+     |                         .___.-'   |          \
+     \                        /` \|      /           ;
+      `-.___             ___.' .-.`.---.|             \
+         \| ``-..___,.-'`\| / /   /     |              `\
+          `      \|      ,`/ /   /   ,  /
+                  `      |\ /   /    |\/
+                   ,   .'`-;   '     \/
+              ,    |\-'  .'   ,   .-'`
+            .-|\--;`` .-'     |\.'
+           ( `"'-.|\ (___,.--'`'
+            `-.    `"`          _.--'
+               `.          _.-'`-.
+                 `''---''``       `."

machineconfig/utils/files/art/water_croco.txt

@@ -0,0 +1,11 @@
+                     _.---._     .---.
+            __...---' .---. `---'-.   `.
+  ~ -~ -.-''__.--' _.'( | )`.  `.  `._ :
+ -.~~ .'__-'_ .--'' ._`---'_.-.  `.   `-`.
+  ~ ~_~-~-~_ ~ -._ -._``---. -.    `-._   `.
+    ~- ~ ~ -_ -~ ~ -.._ _ _ _ ..-_ `.  `-._``--.._
+     ~~-~ ~-_ _~ ~-~ ~ -~ _~~_-~ -._  `-.  -. `-._``--.._.--''. ~ -~_
+         ~~ -~_-~ _~- _~~ _~-_~ ~-_~~ ~-.___    -._  `-.__   `. `. ~ -_~
+             ~~ _~- ~~- -_~  ~- ~ - _~~- _~~ ~---...__ _    ._ .` `. ~-_~
+                ~ ~- _~~- _-_~ ~-_ ~-~ ~_-~ _~- ~_~-_~  ~--.....--~ -~_ ~
+                     ~ ~ - ~  ~ ~~ - ~~-  ~~- ~-  ~ -~ ~ ~ -~~-  ~- ~-~

machineconfig/utils/files/ascii_art.py

@@ -0,0 +1,118 @@
+"""Ascii art
+"""
+
+import os
+import random
+import textwrap
+import subprocess
+from pathlib import Path
+import tempfile
+import platform
+from typing import Optional, Literal
+
+# https://github.com/sepandhaghighi/art
+
+
+BOX_OR_CHAR = Literal['boxes', 'cowsay']
+
+
+class ArtLib:
+    @staticmethod
+    def cowsay(text: str):
+        import cowsay
+        char = random.choice(cowsay.char_names)
+        return cowsay.get_output_string(char, text=text)
+
+
+class BoxStyles:
+    language = ['ada-box', 'caml', 'boxquote', 'stone', 'tex-box', 'shell', 'simple', 'c', 'cc', 'html']
+    scene = ['whirly', 'xes', 'columns', 'parchment', 'scroll', 'scroll-akn', 'diamonds', 'headline', 'nuke', 'spring', 'stark1']  # , 'important3'
+    character = ['capgirl', 'cat', 'boy', 'girl', 'dog', 'mouse', 'santa', 'face', 'ian_jones', 'peek', 'unicornsay']
+
+
+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'
+
+
+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',
+               'Basic', 'Big Money-ne', 'Big Money-nw', 'Big Money-se', 'Big Money-sw', 'Big', 'Bloody', 'Bolger', 'Braced', 'Bright',
+               'DOS Rebel',
+               'Elite', 'Epic', 'Flower Power',
+               'Fraktur',  # 'Isometric4'. 'AMC Tubes', 'Banner3', Alligator2
+               'Star Wars',
+               'Sub-Zero', 'The Edge', 'USA Flag', 'Varsity', "Doom"
+               ]  # too large  Crazy 'Sweet', 'Electronic', 'Swamp Land', Crawford, Alligator
+
+
+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
+    """
+    if comment is None:
+        try:
+            comment = subprocess.run("fortune", shell=True, capture_output=True, text=True, check=True).stdout
+        except Exception:
+            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}"""
+    else:
+        if style is None: style = random.choice(CowStyles.figures)
+        cmd = f"""echo "{comment}" | /usr/games/cowsay -f {style} {to_file}"""
+    try:
+        res = subprocess.run(cmd, text=True, capture_output=True, shell=True, check=True).stdout
+    except subprocess.CalledProcessError as ex:
+        print(ex)
+        return ""
+    res = textwrap.indent(res, prefix=prefix)
+    if verbose:
+        print(f'Using style: {style} from {artlib}', '\n' * 3)
+        print(f'{cmd=}')
+        print('Results:\n', res)
+    return res
+
+
+def font_box_color(logo: str):
+    font = random.choice(FIGJS_FONTS)
+    # print(f"{font}\n")
+    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
+    # print("after")
+
+
+def character_color(logo: str):
+    assert platform.system() == 'Windows', 'This function is only for Windows.'
+    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
+
+
+def character_or_box_color(logo: str):
+    assert platform.system() in {'Linux', 'Darwin'}, 'This function is only for Linux and macOS.'
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
+        _new_art = f.name
+    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"
+    os.system(command)
+
+
+if __name__ == '__main__':
+    pass