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

machineconfig/scripts/python/helpers_devops/themes/choose_pwsh_theme.ps1

@@ -0,0 +1,81 @@
+# Requires: fzf, oh-my-posh
+# Purpose: Interactive Oh My Posh theme chooser with live preview
+
+# Path to your Oh My Posh themes directory
+$themesDir = "$env:LOCALAPPDATA\Programs\oh-my-posh\themes"
+
+if (-not (Test-Path $themesDir)) {
+    Write-Host "Themes directory not found at $themesDir" -ForegroundColor Red
+    exit 1
+}
+
+# Get all theme files and extract just the theme names for display
+$themes = Get-ChildItem $themesDir -Filter "*.omp.json" | ForEach-Object {
+    [PSCustomObject]@{
+        Name = $_.BaseName
+        Path = $_.FullName
+    }
+}
+
+# Create a simple preview command that shows theme name and a sample prompt
+$previewCommand = "pwsh -NoProfile -Command `"Write-Host 'Theme: ' -NoNewline -ForegroundColor Cyan; Write-Host (Split-Path '{}' -Leaf); Write-Host ''; oh-my-posh print primary --config '{}' 2>`$null`""
+
+# Run fzf with preview
+$selectedThemeName = $themes | ForEach-Object { $_.Path } |
+    fzf --height 80% --border --ansi --reverse `
+        --header "Select an Oh My Posh theme (Ctrl+C to cancel)" `
+        --preview $previewCommand `
+        --preview-window=right:60%:wrap
+
+# After fzf selection
+if ($selectedThemeName) {
+    Write-Host "`nYou selected:" -ForegroundColor Green
+    Write-Host (Split-Path $selectedThemeName -Leaf) -ForegroundColor Yellow
+    Write-Host "`nApplying theme..." -ForegroundColor Cyan
+    
+    # Apply the theme to current session
+    oh-my-posh init pwsh --config $selectedThemeName | Invoke-Expression
+    
+    Write-Host "`nTheme applied to current session!" -ForegroundColor Green
+    
+    # Safely update the PowerShell profile
+    $profilePath = $PROFILE
+    $ompLine = "oh-my-posh init pwsh --config '$selectedThemeName' | Invoke-Expression"
+    
+    # Create profile directory if it doesn't exist
+    $profileDir = Split-Path $profilePath -Parent
+    if (-not (Test-Path $profileDir)) {
+        New-Item -ItemType Directory -Path $profileDir -Force | Out-Null
+    }
+    
+    # Read existing profile content or create empty array
+    if (Test-Path $profilePath) {
+        $profileContent = Get-Content $profilePath -Raw
+    } else {
+        $profileContent = ""
+    }
+    
+    # Check if oh-my-posh line already exists and replace it
+    if ($profileContent -match "oh-my-posh init pwsh[^\r\n]*") {
+        # Replace existing oh-my-posh line
+        $profileContent = $profileContent -replace "oh-my-posh init pwsh[^\r\n]*", $ompLine
+    } else {
+        # Add the oh-my-posh line with proper newlines
+        if ($profileContent.Length -gt 0 -and -not $profileContent.EndsWith("`n")) {
+            $profileContent += "`n"
+        }
+        if ($profileContent.Length -gt 0) {
+            $profileContent += "`n"
+        }
+        $profileContent += $ompLine
+        $profileContent += "`n"
+    }
+    
+    # Write back to profile
+    $profileContent | Set-Content $profilePath -Encoding UTF8 -NoNewline
+    
+    Write-Host "Profile updated successfully!" -ForegroundColor Green
+    Write-Host "The theme will be applied automatically in future PowerShell sessions." -ForegroundColor Cyan
+} else {
+    Write-Host "`nNo theme selected." -ForegroundColor DarkGray
+}

machineconfig/scripts/python/helpers_devops/themes/choose_starship_theme.bash

@@ -0,0 +1,3 @@
+
+
+

machineconfig/scripts/python/{choose_wezterm_theme.py → helpers_devops/themes/choose_wezterm_theme.py}

@@ -52,14 +52,14 @@ def main2():
 
 def set_theme(theme: str):
     print(f"🔄 Setting WezTerm theme to: {theme}")
-    txt_lines = PathExtended("~/.config/wezterm/wezterm.lua").expanduser().read_text(encoding="utf-8").splitlines()
+    txt_lines = PathExtended.home().joinpath(".config/wezterm/wezterm.lua").expanduser().read_text(encoding="utf-8").splitlines()
     res_lines = []
     for line in txt_lines:
         if "config.color_scheme = " in line:
             res_lines.append(f"config.color_scheme = '{theme}'")
         else:
             res_lines.append(line)
-    PathExtended("~/.config/wezterm/wezterm.lua").expanduser().write_text("\n".join(res_lines), encoding="utf-8")
+    PathExtended.home().joinpath(".config/wezterm/wezterm.lua").expanduser().write_text("\n".join(res_lines), encoding="utf-8")
     time.sleep(0.1)
     print("💾 Configuration saved")
 

machineconfig/scripts/python/{helpers/helpers4.py → helpers_fire_command/file_wrangler.py}

@@ -1,24 +1,7 @@
-
 from typing import Optional
 import os
-from machineconfig.utils.path_extended import PathExtended
-
-
-def search_for_files_of_interest(path_obj: PathExtended):
-    if path_obj.joinpath(".venv").exists():
-        path_objects = path_obj.search("*", not_in=[".venv"])
-        files: list[PathExtended] = []
-        for a_path_obj in path_objects:
-            files += search_for_files_of_interest(path_obj=a_path_obj)
-        return files
-    if path_obj.is_file():
-        return [path_obj]
-    py_files = path_obj.search(pattern="*.py", not_in=["__init__.py"], r=True)
-    ps_files = path_obj.search(pattern="*.ps1", r=True)
-    sh_files = path_obj.search(pattern="*.sh", r=True)
-    files = py_files + ps_files + sh_files
-    return files
-
+from pathlib import Path
+import platform
 
 
 def parse_pyfile(file_path: str):
@@ -29,7 +12,7 @@ def parse_pyfile(file_path: str):
     func_args: list[list[args_spec]] = [[]]  # this firt prepopulated dict is for the option 'RUN AS MAIN' which has no args
     import ast
 
-    parsed_ast = ast.parse(PathExtended(file_path).read_text(encoding="utf-8"))
+    parsed_ast = ast.parse(Path(file_path).read_text(encoding="utf-8"))
     functions = [node for node in ast.walk(parsed_ast) if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))]
     module__doc__ = ast.get_docstring(parsed_ast)
     main_option = f"RUN AS MAIN -- {module__doc__ if module__doc__ is not None else 'NoDocs'}"
@@ -110,3 +93,56 @@ def get_import_module_code(module_path: str):
         module_name = "IncorrectModuleName"
     # TODO: use py_compile to check if the statement is valid code to avoid syntax errors that can't be caught.
     return f"from {module_name} import *"
+
+
+def wrap_import_in_try_except(import_line: str, pyfile: str, repo_root: Optional[str] = None) -> None:
+    try:
+        exec(import_line)  # type: ignore
+    except (ImportError, ModuleNotFoundError) as ex:
+        print(fr"❌ Failed to import `{pyfile}` as a module: {ex} ")
+        print("⚠️ Attempting import with ad-hoc `$PATH` manipulation. DO NOT pickle any objects in this session as correct deserialization cannot be guaranteed.")
+        import sys
+        sys.path.append(str(Path(pyfile).parent))
+        if repo_root is not None:
+            sys.path.append(repo_root)
+        exec(f"from {Path(pyfile).stem} import *")
+        print(fr"✅ Successfully imported `{pyfile}`")
+
+
+def add_to_path(path_variable: str, directory: str) -> str:
+    """
+    Generate shell script to add directory to path_variable.
+    Handles both Windows (cmd) and Unix-like systems (bash/zsh).
+    Checks if variable exists before appending, otherwise creates it.
+    """
+    system = platform.system()
+    
+    if system == "Windows":
+        script = f"""# Check if {path_variable} is defined
+if (Test-Path env:{path_variable}) {{
+    Write-Host "Adding {directory} to existing {path_variable}"
+    $currentValue = [Environment]::GetEnvironmentVariable("{path_variable}", "User")
+    $newValue = "$currentValue;{directory}"
+    [Environment]::SetEnvironmentVariable("{path_variable}", $newValue, "User")
+    $env:{path_variable} = $newValue
+}} else {{
+    Write-Host "Creating new {path_variable} variable"
+    [Environment]::SetEnvironmentVariable("{path_variable}", "{directory}", "User")
+    $env:{path_variable} = "{directory}"
+}}
+Write-Host "{path_variable} is now: $env:{path_variable}\""""
+        return script
+    else:
+        script = f"""#!/bin/bash
+# Check if {path_variable} is defined and not empty
+if [ -z "${{{path_variable}}}" ]; then
+    echo "Creating new {path_variable} variable"
+    export {path_variable}="{directory}"
+else
+    echo "Adding {directory} to existing {path_variable}"
+    export {path_variable}="${{{path_variable}}}:{directory}"
+fi
+echo "{path_variable} is now: ${{{path_variable}}}"
+"""
+        return script
+

machineconfig/scripts/python/{fire_jobs_args_helper.py → helpers_fire_command/fire_jobs_args_helper.py}

@@ -15,6 +15,7 @@ class FireJobArgs:
     choose_function: bool = False
     loop: bool = False
     jupyter: bool = False
+    marimo: bool = False
     submit_to_cloud: bool = False
     remote: bool = False
     module: bool = False
@@ -24,7 +25,6 @@ class FireJobArgs:
     PathExport: bool = False
     git_pull: bool = False
     optimized: bool = False
-    Nprocess: int = 1
     zellij_tab: Optional[str] = None
     watch: bool = False
 
@@ -96,6 +96,10 @@ def _convert_value_type(value: str) -> object:
     elif value.lower() in ('false', '0', 'no', 'off'):
         return False
     
+    # Try to convert None
+    if value.lower() == 'none':
+        return None
+    
     # Try to parse as list (comma-separated values)
     if ',' in value:
         items = [_convert_value_type(item.strip()) for item in value.split(',')]

machineconfig/scripts/python/{fire_jobs_route_helper.py → helpers_fire_command/fire_jobs_route_helper.py}

@@ -5,7 +5,52 @@ from typing import Optional
 import tomllib
 from pathlib import Path
 from machineconfig.utils.accessories import randstr
-from machineconfig.utils.path_extended import PathExtended
+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:
@@ -36,7 +81,7 @@ def get_command_streamlit(choice_file: Path, environment: str, repo_root: Option
                 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/{PathExtended(repo_root).name}/{choice_file.name}/secrets.toml")
+            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":

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"))