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

machineconfig/scripts/python/croshell.py

@@ -2,75 +2,77 @@
 
 """
 croshell
+
 """
 
 from typing import Annotated, Optional
 import typer
 
 
-
 def croshell(
     path: Annotated[Optional[str], typer.Argument(help="path of file to read.")] = None,
-    python: Annotated[bool, typer.Option("--python", "-p", help="flag to use python over IPython.")] = False,
-    profile: Annotated[Optional[str], typer.Option("--profile", "-P", help="ipython profile to use, defaults to default profile.")] = 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,
-    streamlit_viewer: Annotated[bool, typer.Option("--streamlit", "-s", help="view in streamlit app")] = False,
     visidata: Annotated[bool, typer.Option("--visidata", "-v", help="open data file in visidata")] = False,
-    marimo: Annotated[bool, typer.Option("--marimo", "-m", help="open the notebook using marimo if available")] = 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:
-    from machineconfig.scripts.python.helpers_croshell.crosh import code, get_read_data_pycode
+    if uv_with is not None: user_uv_with_line = f"--with {uv_with} "
+    else: user_uv_with_line = ""
+
+    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 machineconfig.utils.path_extended import PathExtended
     from pathlib import Path
     from machineconfig.utils.accessories import randstr
+    from machineconfig.utils.ve import get_ve_path_and_ipython_profile
     import json
-    from machineconfig.utils.options import choose_from_options
     from rich.console import Console
     from rich.panel import Panel
     console = Console()
 
+
     # ==================================================================================
     # 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 path == ".":
-        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 path != "" and path is not None:
-        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")
-            print("Streamlit viewer is not yet implemented in this version.")
-            return None
-        file_obj = PathExtended(str(path).lstrip()).expanduser().absolute()
-        program = lambda_to_python_script(lambda: get_read_data_pycode(path=str(file_obj)), in_global=True, import_module=False)
-        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 = ""
+
+    if Path.home().joinpath("code/machineconfig").exists() and uv_project_line == "":
+        uv_project_line = f'--project "{str(Path.home().joinpath("code/machineconfig"))}"'
+
     preprogram = """
 #%%
 """
@@ -81,17 +83,19 @@ def croshell(
         from pathlib import Path
         from machineconfig.utils.path_extended import PathExtended
         _ = Path, PathExtended  # avoid unused import warnings
-    import inspect, textwrap
+    import inspect
+    import 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)
 
-    pyfile = PathExtended.tmp().joinpath(f"tmp_scripts/python/croshell/{randstr()}/script.py")
+    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"
-    def_code = lambda_to_python_script(lambda: code(path=str(pyfile), title=title), in_global=False, import_module=False)
+    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")
@@ -125,37 +129,40 @@ def croshell(
             pass
     if visidata:
         if file_obj.suffix == ".json":
-            fire_line = f"uv run --python 3.14 --with visidata vd {str(file_obj)}"
+            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 --python 3.14 --with visidata,pyarrow vd {str(file_obj)}"
+            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"""--with marimo --project "{str(Path.home().joinpath("code/machineconfig"))}" """
-        else: requirements = """--python 3.14 --with "marimo,machineconfig[plot]>=7.50" """
+        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]>=8.12" """
         fire_line = f"""
 cd {str(pyfile.parent)}
-uv run --python 3.14 --with "marimo" marimo convert {pyfile.name} -o marimo_nb.py
+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:
-        if Path.home().joinpath("code/machineconfig").exists(): requirements = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" --with jupyterlab """
-        else: requirements = """--with "machineconfig[plot]>=7.50" """
-        fire_line = f"uv run {requirements} jupyter-lab {str(nb_target)}"
+        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]>=8.12" """
+        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 --python 3.14
+uv init {uv_python_line}
 uv venv
-uv add "machineconfig[plot]>=7.50"
+uv add "cowsay,machineconfig[plot]>=8.12"
+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 = ""
-        if Path.home().joinpath("code/machineconfig").exists(): ve_line = f"""--project "{str(Path.home().joinpath("code/machineconfig"))}" """
-        else: ve_line = """--python 3.14 --with "machineconfig[plot]>=7.50" """
-        # ve_path_maybe, ipython_profile_maybe = get_ve_path_and_ipython_profile(Path.cwd())
-        # --python 3.14
+        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]>=8.12" """
         fire_line = f"uv run {ve_line} {interpreter} {interactivity} {profile} {str(pyfile)}"
 
     from machineconfig.utils.code import exit_then_run_shell_script

machineconfig/scripts/python/devops.py

@@ -8,39 +8,59 @@ 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_devops.run_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", "-ia", help="Interactive selection of programs to install.")] = False,
+        interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of programs to install.")] = False,
     ) -> None:
-        """📦 Install essential packages"""
-        import machineconfig.utils.installer_utils.installer as installer_entry_point
-        installer_entry_point.main(which=which, group=group, interactive=interactive)
+        """📦 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():
-    app = typer.Typer(help="🛠️ DevOps operations", no_args_is_help=True, add_help_option=False,
-                      add_completion=False)
-    _ = install
-    app.command("install", no_args_is_help=True, help="🛠️ [i] Install essential packages")(install)
-    app.command("i", no_args_is_help=True, help="Install essential packages", hidden=True)(install)
+
+    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=install.__doc__, short_help="🛠️ [i] Install essential packages")(install)
+    cli_app.command("i", no_args_is_help=True, help=install.__doc__, hidden=True)(install)
+
     app_repos = cli_repos.get_app()
-    app.add_typer(app_repos, name="repos")
-    app.add_typer(app_repos, name="r", hidden=True)
+    cli_app.add_typer(app_repos, name="repos")
+    cli_app.add_typer(app_repos, name="r", hidden=True)
     app_config = cli_config.get_app()
-    app.add_typer(app_config, name="config")
-    app.add_typer(app_config, name="c", hidden=True)
+    cli_app.add_typer(app_config, name="config")
+    cli_app.add_typer(app_config, name="c", hidden=True)
     app_data = cli_data.get_app()
-    app.add_typer(app_data, name="data")
-    app.add_typer(app_data, name="d", hidden=True)
+    cli_app.add_typer(app_data, name="data")
+    cli_app.add_typer(app_data, name="d", hidden=True)
     app_self = cli_self.get_app()
-    app.add_typer(app_self, name="self")
-    app.add_typer(app_self, name="s", hidden=True)
+    cli_app.add_typer(app_self, name="self")
+    cli_app.add_typer(app_self, name="s", hidden=True)
     app_nw = cli_network.get_app()
-    app.add_typer(app_nw, name="network")
-    app.add_typer(app_nw, name="n", hidden=True)
-    return app
+    cli_app.add_typer(app_nw, name="network")
+    cli_app.add_typer(app_nw, name="n", hidden=True)
+
+    cli_app.command("execute", no_args_is_help=True, help=run_py_script_module.__doc__,
+                    short_help="▶️ [e] Execute python/shell scripts from pre-defined directories or as command",
+                    context_settings={"show_help_on_error": True})(run_py_script_module.run_py_script)
+    cli_app.command("e", no_args_is_help=True, help=run_py_script_module.__doc__, hidden=True)(run_py_script_module.run_py_script)
+
+    return cli_app
 
 
 def main():

machineconfig/scripts/python/devops_navigator.py

@@ -1,7 +1,3 @@
-"""
-TUI for navigating through machineconfig command structure using Textual.
-"""
-
 from machineconfig.scripts.python.helpers_navigator import CommandNavigatorApp
 
 

machineconfig/scripts/python/env_manager/env_manager_tui.py

@@ -0,0 +1,204 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "machineconfig>=8.12",
+#     "textual",
+#     "pyperclip",
+# ]
+# ///
+
+
+
+import os
+import platform
+from collections.abc import Mapping
+from typing import Final
+
+from rich.text import Text
+from textual import on
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import Footer, Header, Label, ListItem, ListView, Static
+
+
+VALUE_PREVIEW_LIMIT: Final[int] = 4096
+SUMMARY_LIMIT: Final[int] = 96
+
+
+def truncate_text(text: str, limit: int) -> tuple[str, int]:
+    length = len(text)
+    if length <= limit:
+        return text, 0
+    return text[:limit], length - limit
+
+
+def format_summary(env_key: str, env_value: str, limit: int) -> str:
+    sanitized = env_value.replace("\n", "\\n").replace("\t", "\\t")
+    preview, remainder = truncate_text(sanitized, limit)
+    if preview == "":
+        base = f"{env_key} = <empty>"
+    else:
+        base = f"{env_key} = {preview}"
+    if remainder == 0:
+        return base
+    return f"{base}... (+{remainder} chars)"
+
+
+def collect_environment(env: Mapping[str, str]) -> list[tuple[str, str]]:
+    return sorted(env.items(), key=lambda pair: pair[0].lower())
+
+
+class EnvListItem(ListItem):
+    def __init__(self, env_key: str, summary: str) -> None:
+        super().__init__(Label(summary))
+        self._env_key = env_key
+
+    def env_key(self) -> str:
+        return self._env_key
+
+
+class EnvValuePreview(Static):
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        super().__init__(*args, **kwargs)
+        self.border_title = "Environment Value"
+
+    def show_value(self, env_key: str, env_value: str) -> None:
+        preview, remainder = truncate_text(env_value, VALUE_PREVIEW_LIMIT)
+        text = Text()
+        text.append(f"{env_key}\n\n", style="bold cyan")
+        if preview == "":
+            text.append("<empty>", style="dim")
+        else:
+            text.append(preview)
+        if remainder > 0:
+            text.append(f"\n... truncated {remainder} characters", style="yellow")
+        self.update(text)
+
+
+class StatusBar(Static):
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        super().__init__(*args, **kwargs)
+        self.border_title = "Status"
+
+    def show_message(self, message: str, level: str) -> None:
+        palette = {
+            "info": "cyan",
+            "success": "green",
+            "warning": "yellow",
+            "error": "red",
+        }
+        color = palette.get(level, "white")
+        self.update(f"[{color}]{message}[/{color}]")
+
+
+class EnvExplorerApp(App[None]):
+    CSS = """
+    Screen { background: $surface; }
+    Header { background: $primary; color: $text; }
+    Footer { background: $panel; }
+    #main-container { height: 100%; }
+    #left-panel { width: 50%; height: 100%; border: solid $primary; padding: 1; }
+    #right-panel { width: 50%; height: 100%; border: solid $accent; padding: 1; }
+    ListView { height: 1fr; border: solid $accent; background: $surface; }
+    ListView > ListItem { padding: 0 1; }
+    EnvValuePreview { height: 1fr; border: solid $primary; background: $surface; padding: 1; overflow-y: auto; }
+    StatusBar { height: 3; border: solid $success; background: $surface; padding: 1; }
+    Label { padding: 0 1; height: auto; }
+    """
+
+    BINDINGS = [
+        Binding("q", "quit", "Quit", show=True),
+        Binding("r", "refresh", "Refresh", show=True),
+        Binding("c", "copy_entry", "Copy", show=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._env_pairs: list[tuple[str, str]] = []
+        self._env_lookup: dict[str, str] = {}
+        self._selected_key: str = ""
+
+    def compose(self) -> ComposeResult:
+        platform_name = platform.system()
+        yield Header(show_clock=True)
+        with Horizontal(id="main-container"):
+            with Vertical(id="left-panel"):
+                yield Label(f"🌐 Environment Variables ({platform_name})")
+                yield ListView(id="env-list")
+            with Vertical(id="right-panel"):
+                yield EnvValuePreview(id="preview")
+                yield StatusBar(id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self.title = "Environment Explorer"
+        self.sub_title = f"Platform: {platform.system()}"
+        self._reload_environment()
+        self._status().show_message("Ready. Select a variable to preview its value.", "info")
+
+    def _reload_environment(self) -> None:
+        self._env_pairs = collect_environment(os.environ)
+        self._env_lookup = dict(self._env_pairs)
+        self._populate_list()
+
+    def _populate_list(self) -> None:
+        list_view = self.query_one("#env-list", ListView)
+        list_view.clear()
+        for env_key, env_value in self._env_pairs:
+            summary = format_summary(env_key, env_value, SUMMARY_LIMIT)
+            list_view.append(EnvListItem(env_key, summary))
+        self._status().show_message(f"Loaded {len(self._env_pairs)} environment variables.", "success")
+
+    def _status(self) -> StatusBar:
+        return self.query_one("#status", StatusBar)
+
+    def _preview(self) -> EnvValuePreview:
+        return self.query_one("#preview", EnvValuePreview)
+
+    @on(ListView.Highlighted)
+    def handle_highlight(self, event: ListView.Highlighted) -> None:
+        if not isinstance(event.item, EnvListItem):
+            return
+        env_key = event.item.env_key()
+        env_value = self._env_lookup.get(env_key, "")
+        self._preview().show_value(env_key, env_value)
+        self._status().show_message(f"Previewing {env_key}", "info")
+
+    @on(ListView.Selected)
+    def handle_selection(self, event: ListView.Selected) -> None:
+        if not isinstance(event.item, EnvListItem):
+            return
+        env_key = event.item.env_key()
+        self._selected_key = env_key
+        env_value = self._env_lookup.get(env_key, "")
+        self._preview().show_value(env_key, env_value)
+        self._status().show_message(f"Selected {env_key}", "success")
+
+    def action_refresh(self) -> None:
+        self._reload_environment()
+        self._status().show_message("Environment reloaded.", "success")
+
+    def action_copy_entry(self) -> None:
+        if self._selected_key == "":
+            self._status().show_message("No variable selected.", "warning")
+            return
+        env_value = self._env_lookup.get(self._selected_key, "")
+        payload = f"{self._selected_key}={env_value}"
+        try:
+            import pyperclip  # type: ignore[import]
+
+            pyperclip.copy(payload)
+            self._status().show_message(f"Copied {self._selected_key} to clipboard.", "success")
+        except ImportError:
+            self._status().show_message("pyperclip unavailable. Install it for clipboard support.", "warning")
+
+
+def main() -> None:
+    app = EnvExplorerApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/env_manager/path_manager_tui.py

@@ -2,7 +2,7 @@
 # /// script
 # requires-python = ">=3.13"
 # dependencies = [
-#     "machineconfig>=7.50",
+#     "machineconfig>=8.12",
 #     "textual",
 #     "pyperclip",
 # ]