machineconfig 3.99__py3-none-any.whl → 7.66__py3-none-any.whl

machineconfig/scripts/python/helpers_fire_command/fire_jobs_route_helper.py

@@ -0,0 +1,110 @@
+
+
+import platform
+from typing import Optional
+import tomllib
+from pathlib import Path
+from machineconfig.utils.accessories import randstr
+from machineconfig.utils.options import choose_from_options
+
+
+def choose_function_or_lines(choice_file: Path, kwargs_dict: dict[str, object]) -> tuple[Optional[str], Path, dict[str, object]]:
+    """
+    Choose a function to run from a Python file or lines from a shell script.
+    
+    Returns:
+        tuple: (choice_function, choice_file, kwargs_dict)
+        - choice_function: The selected function name or None
+        - choice_file: The file path (potentially modified for shell scripts)
+        - kwargs_dict: Updated kwargs dictionary with user-provided arguments
+    """
+    choice_function: Optional[str] = None
+    
+    if choice_file.suffix == ".py":
+        from machineconfig.scripts.python.helpers_fire_command.file_wrangler import parse_pyfile
+        options, func_args = parse_pyfile(file_path=str(choice_file))
+        choice_function_tmp = choose_from_options(msg="Choose a function to run", options=options, fzf=True, multi=False)
+        assert isinstance(choice_function_tmp, str), f"choice_function must be a string. Got {type(choice_function_tmp)}"
+        choice_index = options.index(choice_function_tmp)
+        choice_function = choice_function_tmp.split(" -- ")[0]
+        choice_function_args = func_args[choice_index]
+
+        if choice_function == "RUN AS MAIN":
+            choice_function = None
+        if len(choice_function_args) > 0 and len(kwargs_dict) == 0:
+            for item in choice_function_args:
+                kwargs_dict[item.name] = input(f"Please enter a value for argument `{item.name}` (type = {item.type}) (default = {item.default}) : ") or item.default
+    elif choice_file.suffix == ".sh":
+        options = []
+        for line in choice_file.read_text(encoding="utf-8").splitlines():
+            if line.startswith("#"):
+                continue
+            if line == "":
+                continue
+            if line.startswith("echo"):
+                continue
+            options.append(line)
+        chosen_lines = choose_from_options(msg="Choose a line to run", options=options, fzf=True, multi=True)
+        choice_file = Path.home().joinpath(f"tmp_results/tmp_scripts/shell/{randstr(10)}.sh")
+        choice_file.parent.mkdir(parents=True, exist_ok=True)
+        choice_file.write_text("\n".join(chosen_lines), encoding="utf-8")
+        choice_function = None
+    
+    return choice_function, choice_file, kwargs_dict
+
+
+def get_command_streamlit(choice_file: Path, environment: str, repo_root: Optional[Path]) -> str:
+    import socket
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("8.8.8.8", 1))
+        local_ip_v4 = s.getsockname()[0]
+    except Exception:
+        local_ip_v4 = socket.gethostbyname(socket.gethostname())
+    finally:
+        s.close()
+    computer_name = platform.node()
+    port = 8501
+    toml_path: Optional[Path] = None
+    toml_path_maybe = choice_file.parent.joinpath(".streamlit/config.toml")
+    if toml_path_maybe.exists():
+        toml_path = toml_path_maybe
+    elif choice_file.parent.name == "pages":
+        toml_path_maybe = choice_file.parent.parent.joinpath(".streamlit/config.toml")
+        if toml_path_maybe.exists():
+            toml_path = toml_path_maybe
+    if toml_path is not None:
+        print(f"📄 Reading config.toml @ {toml_path}")
+        config = tomllib.loads(toml_path.read_text(encoding="utf-8"))
+        if "server" in config:
+            if "port" in config["server"]:
+                port = config["server"]["port"]
+        secrets_path = toml_path.with_name("secrets.toml")
+        if repo_root is not None:
+            secrets_template_path = Path.home().joinpath(f"dotfiles/creds/streamlit/{Path(repo_root).name}/{choice_file.name}/secrets.toml")
+            if environment != "" and not secrets_path.exists() and secrets_template_path.exists():
+                secrets_template = tomllib.loads(secrets_template_path.read_text(encoding="utf-8"))
+                if environment == "ip":
+                    host_url = f"http://{local_ip_v4}:{port}/oauth2callback"
+                elif environment == "localhost":
+                    host_url = f"http://localhost:{port}/oauth2callback"
+                elif environment == "hostname":
+                    host_url = f"http://{computer_name}:{port}/oauth2callback"
+                else:
+                    host_url = f"http://{environment}:{port}/oauth2callback"
+                try:
+                    secrets_template["auth"]["redirect_uri"] = host_url
+                    secrets_template["auth"]["cookie_secret"] = randstr(35)
+                    secrets_template["auth"]["auth0"]["redirect_uri"] = host_url
+                    # save_toml(obj=secrets_template, path=secrets_path)
+                except Exception as ex:
+                    print(ex)
+                    raise ex
+    message = f"🚀 Streamlit app is running @:\n1- http://{local_ip_v4}:{port}\n2- http://{computer_name}:{port}\n3- http://localhost:{port}"
+    from rich.panel import Panel
+    from rich import print as rprint
+
+    rprint(Panel(message))
+    exe = f"streamlit run --server.address 0.0.0.0 --server.headless true --server.port {port}"
+    # exe = f"cd '{choice_file.parent}'; " + exe
+    return exe

machineconfig/scripts/python/helpers_msearch/__init__.py

@@ -0,0 +1,5 @@
+
+from pathlib import Path
+
+FZFG_LINUX_PATH = Path(__file__).parent.joinpath("scripts_linux", "fzfg")
+FZFG_WINDOWS_PATH = Path(__file__).parent.joinpath("scripts_windows", "fzfg.ps1")

machineconfig/scripts/{linux → python/helpers_msearch/scripts_linux}/fzfag

@@ -13,5 +13,5 @@ IFS=: read -ra selected < <(
         --preview 'batcat --color=always {1} --highlight-line {2}' \
         --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
 )
-[ -n "${selected[0]}" ] && lvim "${selected[0]}" "+${selected[1]}"
+[ -n "${selected[0]}" ] && hx "${selected[0]}" "+${selected[1]}"
 

machineconfig/scripts/{linux → python/helpers_msearch/scripts_linux}/fzfg

@@ -19,5 +19,5 @@ IFS=: read -ra selected < <(
       --preview 'bat --color=always {1} --highlight-line {2}' \
       --preview-window 'up,60%,border-bottom,+{2}+3/3,~3'
 )
-[ -n "${selected[0]}" ] && lvim "${selected[0]}" "+${selected[1]}
+[ -n "${selected[0]}" ] && hx "${selected[0]}:${selected[1]}:${selected[2]}"
 "

machineconfig/scripts/{linux → python/helpers_msearch/scripts_linux}/fzfrga

@@ -13,7 +13,7 @@ rga-fzf() {
 				--preview-window="70%:wrap"
 	)" &&
 	echo "opening $file" &&
-	xdg-open "$file"
+	hx "$file"
 }
 
 

machineconfig/scripts/python/helpers_navigator/__init__.py

@@ -0,0 +1,20 @@
+"""
+Helper modules for the devops navigator TUI application.
+"""
+
+from machineconfig.scripts.python.helpers_navigator.data_models import CommandInfo, ArgumentInfo
+from machineconfig.scripts.python.helpers_navigator.command_builder import CommandBuilderScreen
+from machineconfig.scripts.python.helpers_navigator.command_tree import CommandTree
+from machineconfig.scripts.python.helpers_navigator.command_detail import CommandDetail
+from machineconfig.scripts.python.helpers_navigator.search_bar import SearchBar
+from machineconfig.scripts.python.helpers_navigator.main_app import CommandNavigatorApp
+
+__all__ = [
+    "CommandInfo",
+    "ArgumentInfo",
+    "CommandBuilderScreen",
+    "CommandTree",
+    "CommandDetail",
+    "SearchBar",
+    "CommandNavigatorApp",
+]

machineconfig/scripts/python/helpers_navigator/command_builder.py

@@ -0,0 +1,111 @@
+"""
+Command builder screen for building commands with arguments.
+"""
+
+import re
+from textual.app import ComposeResult
+from textual.containers import Horizontal, VerticalScroll
+from textual.widgets import Static, Input, Label, Button
+from textual.screen import ModalScreen
+from machineconfig.scripts.python.helpers_navigator.data_models import CommandInfo, ArgumentInfo
+
+
+class CommandBuilderScreen(ModalScreen[str]):
+    """Modal screen for building command with arguments."""
+
+    def __init__(self, command_info: CommandInfo) -> None:
+        super().__init__()
+        self.command_info = command_info
+        self.arguments = self._parse_arguments()
+        self.input_widgets: dict[str, Input] = {}
+
+    def _parse_arguments(self) -> list[ArgumentInfo]:
+        """Parse arguments from help_text."""
+        args: list[ArgumentInfo] = []
+        seen_names: set[str] = set()
+
+        if not self.command_info.help_text:
+            return args
+
+        help_text = self.command_info.help_text
+
+        optional_pattern = re.compile(r'--(\w+(?:-\w+)*)\s+<([^>]+)>')
+        for match in optional_pattern.finditer(help_text):
+            arg_name = match.group(1)
+            placeholder = match.group(2)
+            if arg_name not in seen_names:
+                args.append(ArgumentInfo(name=arg_name, is_required=False, is_flag=False, placeholder=placeholder))
+                seen_names.add(arg_name)
+
+        flag_pattern = re.compile(r'--(\w+(?:-\w+)*)(?:\s|$)')
+        for match in flag_pattern.finditer(help_text):
+            arg_name = match.group(1)
+            if arg_name not in seen_names:
+                args.append(ArgumentInfo(name=arg_name, is_required=False, is_flag=True))
+                seen_names.add(arg_name)
+
+        positional_pattern = re.compile(r'<(\w+)>(?!\s*>)')
+        for match in positional_pattern.finditer(help_text):
+            arg_name = match.group(1)
+            if arg_name not in seen_names and not re.search(rf'--\w+\s+<{arg_name}>', help_text):
+                args.append(ArgumentInfo(name=arg_name, is_required=True, is_flag=False, placeholder=arg_name))
+                seen_names.add(arg_name)
+
+        return args
+
+    def compose(self) -> ComposeResult:
+        """Compose the modal screen."""
+        with VerticalScroll():
+            yield Static(f"[bold cyan]Build Command: {self.command_info.command}[/bold cyan]\n", classes="title")
+
+            if not self.arguments:
+                yield Static("[yellow]No arguments needed for this command[/yellow]\n")
+            else:
+                for arg in self.arguments:
+                    if arg.is_flag:
+                        label_text = f"--{arg.name} (flag, leave empty to skip)"
+                        yield Label(label_text)
+                        input_widget = Input(placeholder="yes/no or leave empty", id=f"arg_{arg.name}")
+                    else:
+                        required_marker = "[red]*[/red]" if arg.is_required else "[dim](optional)[/dim]"
+                        label_text = f"--{arg.name} {required_marker}"
+                        yield Label(label_text)
+                        input_widget = Input(placeholder=arg.placeholder or arg.name, id=f"arg_{arg.name}")
+
+                    self.input_widgets[arg.name] = input_widget
+                    yield input_widget
+
+            with Horizontal(classes="buttons"):
+                yield Button("Execute", variant="primary", id="execute")
+                yield Button("Copy", variant="success", id="copy")
+                yield Button("Cancel", variant="error", id="cancel")
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        if event.button.id == "cancel":
+            self.dismiss("")
+            return
+
+        built_command = self._build_command()
+
+        if event.button.id == "execute":
+            self.dismiss(f"EXECUTE:{built_command}")
+        elif event.button.id == "copy":
+            self.dismiss(f"COPY:{built_command}")
+
+    def _build_command(self) -> str:
+        """Build the complete command with arguments."""
+        parts = [self.command_info.command]
+
+        for arg in self.arguments:
+            input_widget = self.input_widgets.get(arg.name)
+            if input_widget:
+                value = input_widget.value.strip()
+                if value:
+                    if arg.is_flag:
+                        if value.lower() in ('yes', 'y', 'true', '1'):
+                            parts.append(f"--{arg.name}")
+                    else:
+                        parts.append(f"--{arg.name} {value}")
+
+        return " ".join(parts)

machineconfig/scripts/python/helpers_navigator/command_detail.py

@@ -0,0 +1,44 @@
+"""
+Command detail widget for displaying command information.
+"""
+
+from typing import Optional
+from textual.widgets import Static
+from rich.panel import Panel
+from rich.text import Text
+from machineconfig.scripts.python.helpers_navigator.data_models import CommandInfo
+
+
+class CommandDetail(Static):
+    """Widget for displaying command details."""
+
+    def __init__(self, *, id: str) -> None:  # type: ignore
+        super().__init__(id=id)
+        self.command_info: Optional[CommandInfo] = None
+
+    def update_command(self, command_info: Optional[CommandInfo]) -> None:
+        """Update displayed command information."""
+        self.command_info = command_info
+        if command_info is None:
+            self.update("Select a command to view details")
+            return
+
+        content = Text()
+        content.append(f"{'🗂️  Group' if command_info.is_group else '⚡ Command'}: ", style="bold cyan")
+        content.append(f"{command_info.name}\n\n", style="bold yellow")
+
+        content.append("Description: ", style="bold green")
+        content.append(f"{command_info.description}\n\n", style="white")
+
+        content.append("Command: ", style="bold blue")
+        content.append(f"{command_info.command}\n\n", style="bold white")
+
+        if command_info.help_text:
+            content.append("Usage: ", style="bold magenta")
+            content.append(f"{command_info.help_text}\n\n", style="white")
+
+        if command_info.module_path:
+            content.append("Module: ", style="bold red")
+            content.append(f"{command_info.module_path}\n", style="white")
+
+        self.update(Panel(content, title=f"[bold]{command_info.name}[/bold]", border_style="blue"))