machineconfig 5.15__py3-none-any.whl → 7.98__py3-none-any.whl

machineconfig/scripts/python/croshell.py

@@ -2,156 +2,180 @@
 
 """
 croshell
+
 """
 
 from typing import Annotated, Optional
 import typer
-from machineconfig.utils.path_extended import PathExtended
-from machineconfig.utils.accessories import randstr
-
-from machineconfig.utils.options import choose_from_options
-# from machineconfig.utils.ve import get_ve_activate_line
-from rich.console import Console
-from rich.panel import Panel
-# from rich.text import Text
 
-console = Console()
 
+def croshell(
+    path: Annotated[Optional[str], typer.Argument(help="path of file to read.")] = None,
+    project_path: Annotated[Optional[str], typer.Option("--project", "-p", help="specify uv project to use")] = None,
+    uv_with: Annotated[Optional[str], typer.Option("--uv-with", "-w", help="specify uv with packages to use")] = None,
+    marimo: Annotated[bool, typer.Option("--marimo", "-m", help="open the notebook using marimo if available")] = False,
+    jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="run in jupyter interactive console")] = False,
+    vscode: Annotated[bool, typer.Option("--vscode", "-c", help="open the script in vscode")] = False,
+    visidata: Annotated[bool, typer.Option("--visidata", "-v", help="open data file in visidata")] = False,
+    # streamlit_viewer: Annotated[bool, typer.Option("--streamlit", "-s", help="view in streamlit app")] = False,
+    python: Annotated[bool, typer.Option("--python", "-P", help="flag to use python over IPython.")] = False,
+    profile: Annotated[Optional[str], typer.Option("--profile", "-r", help="ipython profile to use, defaults to default profile.")] = None,
+    
+) -> None:
+    if uv_with is not None: user_uv_with_line = f"--with {uv_with} "
+    else: user_uv_with_line = ""
 
-def add_print_header_pycode(path: str, title: str):
-    return f"""
-try:
-    from crocodile.file_management import P as PathExtended
-except ImportError:
-    from machineconfig.utils.path_extended import PathExtended
-pycode = PathExtended(r'{path}').read_text(encoding="utf-8")
-pycode = pycode.split("except Exception: print(pycode)")[2]
-
-try:
-    from rich.text import Text
-    from rich.panel import Panel
+    if project_path is not None:
+        uv_project_line = f'--project {project_path}'
+        uv_python_line = ""
+    else:
+        uv_project_line = ""
+        uv_python_line = "--python 3.14"
+
+    from machineconfig.scripts.python.helpers_croshell.crosh import get_read_python_file_pycode, get_read_data_pycode
+    from machineconfig.utils.meta import lambda_to_python_script
+    from pathlib import Path
+    from machineconfig.utils.accessories import randstr
+    from machineconfig.utils.ve import get_ve_path_and_ipython_profile
+    import json
     from rich.console import Console
-    from rich.syntax import Syntax
+    from rich.panel import Panel
     console = Console()
-    if pycode.strip() != "":
-        console.print(Panel(Syntax(pycode, lexer="python"), title='{title}'), style="bold red")
-except Exception: print(pycode)
-"""
-
-
-def get_read_data_pycode(path: str):
-    return f"""
-from rich.panel import Panel
-from rich.text import Text
-from rich.console import Console
-console = Console()
-p = PathExtended(r'{path}').absolute()
-try:
-    from machineconfig.utils.files.read import Read
-    dat = Read.read(p)
-    if isinstance(dat, dict):
-        panel_title = f"📄 File Data: {{p.name}}"
-        console.print(Panel(Text(str(dat), justify="left"), title=panel_title, expand=False))
-        pprint(dat, PathExtended.name)
-    else:
-        panel_title = f"📄 Successfully read the file: {{p.name}}"
-        console.print(Panel(Text(str(dat), justify="left"), title=panel_title, expand=False))
-except Exception as e:
-    error_message = f'''❌ ERROR READING FILE\nFile: {{p.name}}\nError: {{e}}'''
-    console.print(Panel(Text(error_message, justify="left"), title="Error", expand=False, border_style="red"))
-"""
 
 
-
-def main(
-    python: Annotated[bool, typer.Option("--python", "-p", help="flag to use python over IPython.")] = False,
-    fzf: Annotated[bool, typer.Option("--fzf", "-F", help="search with fuzzy finder for python scripts and run them")] = False,
-    ve: Annotated[Optional[str], typer.Option("--ve", "-v", help="virtual enviroment to use, defaults to activated ve, if existed, else ve.")] = None,
-    profile: Annotated[Optional[str], typer.Option("--profile", "-P", help="ipython profile to use, defaults to default profile.")] = None,
-    read: Annotated[str, typer.Option("--read", "-r", help="read a binary file.")] = "",
-    jupyter: Annotated[bool, typer.Option("--jupyter", "-j", help="run in jupyter interactive console")] = False,
-    streamlit_viewer: Annotated[bool, typer.Option("--stViewer", "-s", help="view in streamlit app")] = False,
-    visidata: Annotated[bool, typer.Option("--visidata", "-V", help="open data file in visidata")] = False,
-) -> None:
     # ==================================================================================
     # flags processing
     interactivity = "-i"
     interpreter = "python" if python else "ipython"
     ipython_profile: Optional[str] = profile
-    file_obj = PathExtended.cwd()  # initialization value, could be modified according to args.
-
-    if fzf:
-        text = "🔍 Searching for Python files..."
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-        options = [str(item) for item in PathExtended.cwd().search("*.py", r=True)]
-        file_selected = choose_from_options(msg="Choose a python file to run", options=options, fzf=True, multi=False)
-        assert isinstance(file_selected, str)
-        program = PathExtended(file_selected).read_text(encoding="utf-8")
-        text = f"📄 Selected file: {PathExtended(file_selected).name}"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-
-    elif read != "":
-        if streamlit_viewer:
-            #             text = "📊 STARTING STREAMLIT VIEWER"
-            #             console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-            #             from machineconfig.scripts.python.viewer import run
-            #             py_file_path = run(data_path=args.read, data=None, get_figure=None)
-            #             final_program = f"""
-            # #!/bin/bash
-            # streamlit run {py_file_path}
-            # """
-            #             PROGRAM_PATH.write_text(data=final_program, encoding="utf-8")
-            return None
-        file_obj = PathExtended(str(read).lstrip()).expanduser().absolute()
-        program = get_read_data_pycode(str(file_obj))
-        text = f"📄 Reading data from: {file_obj.name}"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-
+    file_obj = Path.cwd()  # initialization value, could be modified according to args.
+    if path is not None:
+        from machineconfig.utils.path_helper import get_choice_file
+        choice_file = get_choice_file(path=path, suffixes={".*"})
+        if project_path is None:
+            ve_path, _ = get_ve_path_and_ipython_profile(choice_file)
+            if ve_path is not None:
+                ve_path_obj = Path(ve_path)
+                uv_project_line = f'--project {ve_path_obj.parent}'
+                uv_python_line = ""
+        if choice_file.suffix == ".py":
+            program = choice_file.read_text(encoding="utf-8")
+            text = f"📄 Selected file: {choice_file.name}"
+            console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
+        else:
+            program = lambda_to_python_script(lambda: get_read_data_pycode(path=str(choice_file)),
+                                              in_global=True, import_module=False)
+            text = f"📄 Reading data from: {file_obj.name}"
+            console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
     else:  # if nothing is specified, then run in interactive mode.
-        text = "⌨️  Entering interactive mode"
-        console.print(Panel(text, title="[bold blue]Info[/bold blue]"))
-        # from machineconfig.scripts.python.croshell import InteractiveShell
-        # InteractiveShell().run()
-        # return None
         program = ""
 
-    preprogram = """
+    if Path.home().joinpath("code/machineconfig").exists() and uv_project_line == "":
+        uv_project_line = f'--project "{str(Path.home().joinpath("code/machineconfig"))}"'
 
+    preprogram = """
 #%%
-
-from machineconfig.utils.files.headers import print_header, print_logo
-print_header()
-print_logo("CROCODILE")
-from pathlib import Path
-
 """
-
-    pyfile = PathExtended.tmp().joinpath(f"tmp_scripts/python/croshell/{randstr()}.py")
+    def preprogram_func():
+        from machineconfig.utils.files.headers import print_header, print_logo
+        print_header()
+        print_logo("Machineconfig")
+        from pathlib import Path
+        from machineconfig.utils.path_extended import PathExtended
+        _ = Path, PathExtended  # avoid unused import warnings
+    import inspect, textwrap
+    from types import FunctionType
+    def get_body_simple_function_no_args(f: FunctionType):
+        return textwrap.dedent("\n".join(inspect.getsource(f).splitlines()[1:]))
+    preprogram += get_body_simple_function_no_args(preprogram_func)
+
+    from pathlib import Path
+    pyfile = Path.home().joinpath(f"tmp_results/tmp_scripts/python/croshell/{randstr()}/script.py")
     pyfile.parent.mkdir(parents=True, exist_ok=True)
-
     title = "Reading Data"
-    python_program = preprogram + add_print_header_pycode(str(pyfile), title=title) + program
+    def_code = lambda_to_python_script(lambda: get_read_python_file_pycode(path=str(pyfile), title=title),
+                                       in_global=False, import_module=False)
+    # print(def_code)
+    python_program = preprogram + "\n\n" + def_code + program
     pyfile.write_text(python_program, encoding="utf-8")
     # ve_root_from_file, ipython_profile = get_ve_path_and_ipython_profile(PathExtended(file))
     ipython_profile = ipython_profile if ipython_profile is not None else "default"
     # ve_activateion_line = get_ve_activate_line(ve_name=args.ve or ve_profile_suggested, a_path=str(PathExtended.cwd()))
 
+    # prepare notebook target path (avoid relying on locals())
+    nb_target = pyfile.with_suffix(".ipynb")
+    if jupyter:
+        try:
+            nb_path = pyfile.with_suffix(".ipynb")
+            nb_content = {
+                "cells": [
+                    {
+                        "cell_type": "code",
+                        "metadata": {"language": "python"},
+                        "source": [python_program],
+                        "outputs": [],
+                        "execution_count": None,
+                    }
+                ],
+                "metadata": {},
+                "nbformat": 4,
+                "nbformat_minor": 5,
+            }
+            nb_path.write_text(json.dumps(nb_content), encoding="utf-8")
+            nb_target = nb_path
+        except Exception:
+            # if writing fails, fall back to the default nb_target already set
+            pass
     if visidata:
-        fire_line = f"uv run --with visidata,pyarrow vd {str(file_obj)}"
+        if file_obj.suffix == ".json":
+            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --with visidata vd {str(file_obj)}"
+        else:
+            fire_line = f"uv run {uv_python_line} {user_uv_with_line} {uv_project_line} --with visidata,pyarrow vd {str(file_obj)}"
+    elif marimo:
+        if Path.home().joinpath("code/machineconfig").exists():
+            requirements = f"""{user_uv_with_line} {uv_project_line} --with marimo  """
+        else: requirements = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "marimo,cowsay,machineconfig[plot]>=7.98" """
+        fire_line = f"""
+cd {str(pyfile.parent)}
+uv run {uv_python_line} --with "marimo" marimo convert {pyfile.name} -o marimo_nb.py
+uv run {requirements} marimo edit --host 0.0.0.0 marimo_nb.py
+"""
     elif jupyter:
-        fire_line = f"code --new-window {str(pyfile)}"
+        if Path.home().joinpath("code/machineconfig").exists():
+            requirements = f"""{user_uv_with_line}  {uv_project_line}  --with jupyterlab """
+        else: requirements = f"""{user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=7.98" """
+        fire_line = f"uv run {requirements} {uv_project_line}  jupyter-lab {str(nb_target)}"
+    elif vscode:
+        user_uv_add = f"uv add {uv_with}" if uv_with is not None else ""
+        fire_line = f"""
+cd {str(pyfile.parent)}
+uv init {uv_python_line}
+uv venv
+uv add "cowsay,machineconfig[plot]>=7.98"
+uv add {user_uv_add}
+# code serve-web
+code --new-window {str(pyfile)}
+"""
     else:
         if interpreter == "ipython": profile = f" --profile {ipython_profile} --no-banner"
         else: profile = ""
-        fire_line = f"uv run --python 3.13 --with machineconfig[plot] {interpreter} {interactivity} {profile} {str(pyfile)}"
+        if Path.home().joinpath("code/machineconfig").exists():
+            ve_line = f"""{user_uv_with_line}  {uv_project_line} """
+        else: ve_line = f"""{uv_python_line} {user_uv_with_line} {uv_project_line} --with "cowsay,machineconfig[plot]>=7.98" """
+        fire_line = f"uv run {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
 
-    from machineconfig.utils.code import run_shell_script
-    run_shell_script(fire_line)
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(fire_line, strict=False)
 
 
-def arg_parser() -> None:
-    typer.run(main)
+def main() -> None:
+    typer.run(croshell)
 
 
 if __name__ == "__main__":
-    arg_parser()
+    # def func(flag: Annotated[bool, typer.Option("--flag/-nf", help="dummy flag for debugging", flag_value=False, is_flag=True)]=True):
+    #     console.print(f"flag: {flag}")
+    # app = typer.Typer()
+    # app.command()(func)
+    # app()
+    main()

machineconfig/scripts/python/devops.py

@@ -1,106 +1,66 @@
 """devops with emojis"""
 
-import machineconfig.utils.installer_utils.installer as installer_entry_point
-import machineconfig.scripts.python.share_terminal as share_terminal
-import machineconfig.scripts.python.repos as repos
-
-from machineconfig import __version__
 import typer
+from typing import Optional, Annotated
+
+import machineconfig.scripts.python.helpers_devops.cli_repos as cli_repos
+import machineconfig.scripts.python.helpers_devops.cli_config as cli_config
+import machineconfig.scripts.python.helpers_devops.cli_self as cli_self
+import machineconfig.scripts.python.helpers_devops.cli_data as cli_data
+import machineconfig.scripts.python.helpers_devops.cli_nw as cli_network
+import machineconfig.scripts.python.helpers.run_py_script as run_py_script_module
+
+def install(which: Annotated[Optional[str], typer.Argument(..., help="Comma-separated list of program names to install, or group name if --group flag is set.")] = None,
+        group: Annotated[bool, typer.Option(..., "--group", "-g", help="Treat 'which' as a group name. A group is bundle of apps.")] = False,
+        interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
+    ) -> None:
+        """📦 Install packages"""
+        import machineconfig.utils.installer_utils.installer_cli as installer_entry_point
+        installer_entry_point.main_installer_cli(which=which, group=group, interactive=interactive)
+
+
+
+# def get_app():
+#     app = typer.Typer(add_completion=False, no_args_is_help=True)
+#     app.command(name="scripts", help="define all scripts", no_args_is_help=False)(define_scripts)
+#     return app
+
+# def main():
+#     # return app
+#     app = get_app()
+#     app()
+
+#     define_app = get_define_app()
+
+
+def get_app():
+
+    cli_app = typer.Typer(help="🛠️ DevOps operations", no_args_is_help=True, add_help_option=False, add_completion=False)
+    cli_app.command("install", no_args_is_help=True, help="🛠️ [i] Install essential packages")(install)
+    cli_app.command("i", no_args_is_help=True, help="Install essential packages", hidden=True)(install)
+
+    app_repos = cli_repos.get_app()
+    cli_app.add_typer(app_repos, name="repos")
+    cli_app.add_typer(app_repos, name="r", hidden=True)
+    app_config = cli_config.get_app()
+    cli_app.add_typer(app_config, name="config")
+    cli_app.add_typer(app_config, name="c", hidden=True)
+    app_data = cli_data.get_app()
+    cli_app.add_typer(app_data, name="data")
+    cli_app.add_typer(app_data, name="d", hidden=True)
+    app_self = cli_self.get_app()
+    cli_app.add_typer(app_self, name="self")
+    cli_app.add_typer(app_self, name="s", hidden=True)
+    app_nw = cli_network.get_app()
+    cli_app.add_typer(app_nw, name="network")
+    cli_app.add_typer(app_nw, name="n", hidden=True)
+
+    cli_app.command("python", no_args_is_help=True, help="🐍 [p] python scripts or command/file in the machineconfig environment", context_settings={"show_help_on_error": True})(run_py_script_module.run_py_script)
+    cli_app.command("p", no_args_is_help=True, help="RUN python scripts or command/file in the machineconfig environment", hidden=True)(run_py_script_module.run_py_script)
+
+    return cli_app
 
 
-app = typer.Typer(help=f"🛠️ DevOps operations @ machineconfig {__version__}", no_args_is_help=True)
-app.command(name="install", help="📦 Install essential packages")(installer_entry_point.main)
-app.command(name="share-terminal", help="📡 Share terminal via web browser")(share_terminal.main)
-app.add_typer(repos.app, name="repos", help="📁 Manage git repositories")
-
-ssh_app = typer.Typer(help="🔐 SSH operations subcommands", no_args_is_help=True)
-app.add_typer(ssh_app, name="ssh")
-
-
-@app.command()
-def update():
-    """🔄 UPDATE essential repos"""
-    import machineconfig.scripts.python.devops_update_repos as helper
-    helper.main()
-
-
-@app.command()
-def symlinks():
-    """🔗 SYMLINKS of dotfiles."""
-    import machineconfig.profile.create as helper
-    helper.main_symlinks()
-
-
-@app.command()
-def profile():
-    """🔗 Update shell profile."""
-    import machineconfig.profile.create as helper
-    helper.main_profile()
-
-
-@app.command()
-def symlinks_new():
-    """🆕 SYMLINKS new"""
-    import machineconfig.jobs.python.python_ve_symlink as helper
-    helper.main()
-
-
-@ssh_app.command()
-def add_key():
-    """🔑 SSH add pub key to this machine"""
-    import machineconfig.scripts.python.devops_add_ssh_key as helper
-    helper.main()
-@ssh_app.command()
-def add_identity():
-    """🗝️ SSH add identity (private key) to this machine"""
-    import machineconfig.scripts.python.devops_add_identity as helper
-    helper.main()
-@ssh_app.command()
-def connect():
-    """🔐 SSH use key pair to connect two machines"""
-    raise NotImplementedError
-@ssh_app.command()
-def setup():
-    """📡 SSH setup"""
-    _program_windows = """Invoke-WebRequest https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/openssh_all.ps1 | Invoke-Expression  # https://github.com/thisismygitrepo.keys"""
-    _program_linux = """curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_all.sh | sudo bash  # https://github.com/thisismygitrepo.keys"""
-    import subprocess
-    from platform import system
-    subprocess.run(_program_linux if system() == "Linux" else _program_windows, shell=True, check=True)
-@ssh_app.command()
-def setup_wsl():
-    """🐧 SSH setup wsl"""
-    import subprocess
-    subprocess.run("curl https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_linux/openssh_wsl.sh | sudo bash", shell=True, check=True)
-
-
-@app.command()
-def backup():
-    """💾 BACKUP"""
-    from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
-    main_backup_retrieve(direction="BACKUP")
-
-
-@app.command()
-def retrieve():
-    """📥 RETRIEVE"""
-    from machineconfig.scripts.python.devops_backup_retrieve import main_backup_retrieve
-    main_backup_retrieve(direction="RETRIEVE")
-
-
-@app.command()
-def scheduler():
-    """⏰ SCHEDULER"""
-    # from machineconfig.scripts.python.scheduler import main as helper
-    # helper()
-
-@app.command()
-def interactive():
-    """🤖 INTERACTIVE configuration of machine."""
-    from machineconfig.scripts.python.interactive import main
-    main()
-
-
-
-if __name__ == "__main__":
-    pass
+def main():
+    app = get_app()
+    app()

machineconfig/scripts/python/devops_navigator.py

@@ -0,0 +1,6 @@
+from machineconfig.scripts.python.helpers_navigator import CommandNavigatorApp
+
+
+if __name__ == "__main__":
+    app = CommandNavigatorApp()
+    app.run()

machineconfig/scripts/python/env_manager/__init__.py

@@ -0,0 +1 @@
+a = 2