machineconfig 5.58__tar.gz → 5.60__tar.gz

{machineconfig-5.58/src/machineconfig.egg-info → machineconfig-5.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: machineconfig
-Version: 5.58
+Version: 5.60
 Summary: Dotfiles management package
 Author-email: Alex Al-Saffar <programmer@usa.com>
 License: Apache 2.0
@@ -27,6 +27,7 @@ Requires-Dist: pyjson5>=1.6.9
 Requires-Dist: questionary>=2.1.1
 Requires-Dist: typer-slim>=0.19.2
 Requires-Dist: typer>=0.19.2
+Requires-Dist: textual>=6.2.1
 Provides-Extra: windows
 Requires-Dist: pywin32; extra == "windows"
 Provides-Extra: plot

{machineconfig-5.58 → machineconfig-5.60}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "machineconfig"
-version = "5.58"
+version = "5.60"
 description = "Dotfiles management package"
 readme = "README.md"
 license = {text = "Apache 2.0"}
@@ -36,6 +36,7 @@ dependencies = [
     "questionary>=2.1.1",
     "typer-slim>=0.19.2",
     "typer>=0.19.2",
+    "textual>=6.2.1",
 ]
 
 [project.optional-dependencies]

{machineconfig-5.58 → machineconfig-5.60}/src/machineconfig/scripts/python/devops_helpers/cli_config.py

@@ -41,6 +41,14 @@ def shell():
     from machineconfig.profile.create_shell_profile import create_default_shell_profile
     create_default_shell_profile()
 
+@config_apps.command(no_args_is_help=False)
+def path():
+    """📚 NAVIGATE PATH variable with TUI"""
+    from machineconfig.scripts.python import env_manager as navigator
+    from pathlib import Path
+    path = Path(navigator.__file__).resolve().parent.joinpath("path_manager_tui.py")
+    from machineconfig.utils.code import run_shell_script
+    run_shell_script(f"uv run --no-dev --with machineconfig,textual {path}")
 
 @config_apps.command(no_args_is_help=False)
 def pwsh_theme():

{machineconfig-5.58 → machineconfig-5.60}/src/machineconfig/scripts/python/devops_helpers/cli_self.py

@@ -42,7 +42,7 @@ def navigate():
     from pathlib import Path
     path = Path(navigator.__file__).resolve().parent.joinpath("devops_navigator.py")
     from machineconfig.utils.code import run_shell_script
-    run_shell_script(f"uv run --with machineconfig {path}")
+    run_shell_script(f"uv run --no-dev --with machineconfig,textual {path}")
 
 
 @cli_app.command(no_args_is_help=True)

machineconfig-5.60/src/machineconfig/scripts/python/env_manager/__init__.py

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

machineconfig-5.60/src/machineconfig/scripts/python/env_manager/path_manager_backend.py

@@ -0,0 +1,47 @@
+"""Cross-platform PATH explorer backend."""
+
+import os
+import platform
+from pathlib import Path
+from typing import Literal
+
+
+PlatformType = Literal["Windows", "Linux", "Darwin"]
+
+
+def get_platform() -> PlatformType:
+    """Get the current platform."""
+    return platform.system()  # type: ignore[return-value]
+
+
+def get_path_entries() -> list[str]:
+    """Get all PATH entries for the current platform."""
+    path_str = os.environ.get("PATH", "")
+    separator = ";" if get_platform() == "Windows" else ":"
+    return [entry for entry in path_str.split(separator) if entry.strip()]
+
+
+def get_directory_contents(directory: str, max_items: int = 50) -> list[str]:
+    """Get contents of a directory, limited to max_items."""
+    try:
+        path = Path(directory)
+        if not path.exists():
+            return ["⚠️  Directory does not exist"]
+        if not path.is_dir():
+            return ["⚠️  Not a directory"]
+        
+        items = []
+        for item in sorted(path.iterdir(), key=lambda p: (not p.is_dir(), p.name.lower())):
+            if len(items) >= max_items:
+                items.append(f"... and {sum(1 for _ in path.iterdir()) - max_items} more items")
+                break
+            prefix = "📁 " if item.is_dir() else "📄 "
+            items.append(f"{prefix}{item.name}")
+        
+        if not items:
+            return ["📭 Empty directory"]
+        return items
+    except PermissionError:
+        return ["⚠️  Permission denied"]
+    except Exception as e:
+        return [f"⚠️  Error: {e!s}"]

machineconfig-5.60/src/machineconfig/scripts/python/env_manager/path_manager_tui.py

@@ -0,0 +1,219 @@
+"""Cross-platform PATH explorer with Textual TUI."""
+
+from pathlib import Path
+
+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
+
+from machineconfig.scripts.python.env_manager.path_manager_backend import get_directory_contents, get_path_entries, get_platform
+
+
+class DirectoryPreview(Static):
+    """Widget to display directory contents."""
+
+    def __init__(self, *args, **kwargs) -> None:  # type: ignore[no-untyped-def]
+        super().__init__(*args, **kwargs)
+        self.border_title = "📂 Directory Preview"
+
+    def update_preview(self, directory: str) -> None:
+        """Update the preview with directory contents."""
+        if not directory:
+            self.update("Select a PATH entry to preview its contents")
+            return
+
+        contents = get_directory_contents(directory, max_items=30)
+        preview_text = f"[bold cyan]{directory}[/bold cyan]\n\n"
+        preview_text += "\n".join(contents)
+        self.update(preview_text)
+
+
+class StatusBar(Static):
+    """Status bar to show messages."""
+
+    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, message_type: str = "info") -> None:
+        """Display a status message."""
+        color = {"info": "cyan", "success": "green", "error": "red", "warning": "yellow"}.get(message_type, "white")
+        self.update(f"[{color}]{message}[/{color}]")
+
+
+class PathExplorerApp(App[None]):
+    """A Textual app to explore PATH entries."""
+
+    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;
+    }
+
+    ListView > ListItem.--highlight {
+        background: $accent 20%;
+    }
+
+    DirectoryPreview {
+        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_path", "Copy Path", show=True),
+    ]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.selected_path: str = ""
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the app."""
+        platform_name = get_platform()
+        yield Header(show_clock=True)
+        
+        with Horizontal(id="main-container"):
+            with Vertical(id="left-panel"):
+                yield Label(f"🔧 PATH Entries ({platform_name})")
+                yield ListView(id="path-list")
+                
+            with Vertical(id="right-panel"):
+                yield DirectoryPreview(id="preview")
+                yield StatusBar(id="status")
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        """Initialize the app when mounted."""
+        self.title = "PATH Explorer"
+        self.sub_title = f"Platform: {get_platform()}"
+        self.refresh_path_list()
+        self.query_one("#status", StatusBar).show_message("Ready. Select a PATH entry to preview its contents.", "info")
+
+    def refresh_path_list(self) -> None:
+        """Refresh the list of PATH entries."""
+        list_view = self.query_one("#path-list", ListView)
+        list_view.clear()
+        
+        entries = get_path_entries()
+        for entry in entries:
+            path = Path(entry)
+            exists = path.exists()
+            icon = "✅" if exists else "❌"
+            item = ListItem(Label(f"{icon} {entry}"))
+            item.set_class(exists, "--valid")
+            list_view.append(item)
+        
+        self.query_one("#status", StatusBar).show_message(f"Loaded {len(entries)} PATH entries", "success")
+
+    @on(ListView.Highlighted)
+    def handle_highlight(self, event: ListView.Highlighted) -> None:
+        """Handle highlighting of a PATH entry (scroll preview)."""
+        if event.item is None:
+            return
+        label = event.item.query_one(Label)
+        text = label.render()
+        # Remove the icon prefix
+        highlighted_path = str(text).split(" ", 1)[1] if " " in str(text) else str(text)
+        
+        preview = self.query_one("#preview", DirectoryPreview)
+        preview.update_preview(highlighted_path)
+        
+        self.query_one("#status", StatusBar).show_message(f"Previewing: {highlighted_path}", "info")
+
+    @on(ListView.Selected)
+    def handle_selection(self, event: ListView.Selected) -> None:
+        """Handle selection of a PATH entry (Enter key)."""
+        label = event.item.query_one(Label)
+        text = label.render()
+        # Remove the icon prefix
+        self.selected_path = str(text).split(" ", 1)[1] if " " in str(text) else str(text)
+        
+        preview = self.query_one("#preview", DirectoryPreview)
+        preview.update_preview(self.selected_path)
+        
+        self.query_one("#status", StatusBar).show_message(f"Selected: {self.selected_path}", "success")
+
+    def action_refresh(self) -> None:
+        """Refresh the PATH list."""
+        self.refresh_path_list()
+
+    def action_copy_path(self) -> None:
+        """Copy selected path to clipboard."""
+        if not self.selected_path:
+            self.query_one("#status", StatusBar).show_message("No PATH entry selected", "warning")
+            return
+        
+        # Try to copy to clipboard
+        try:
+            import pyperclip
+            pyperclip.copy(self.selected_path)
+            self.query_one("#status", StatusBar).show_message(f"Copied to clipboard: {self.selected_path}", "success")
+        except ImportError:
+            self.query_one("#status", StatusBar).show_message("pyperclip not available. Install it to enable clipboard support.", "warning")
+
+
+def main() -> None:
+    """Run the PATH Explorer TUI."""
+    app = PathExplorerApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

{machineconfig-5.58 → machineconfig-5.60}/src/machineconfig/scripts/python/helpers_repos/cloud_repo_sync.py

@@ -11,7 +11,6 @@ from machineconfig.utils.code import get_shell_file_executing_python_script, wri
 import platform
 import subprocess
 from typing import Optional, Literal
-from pathlib import Path
 
 
 console = Console()
@@ -96,13 +95,14 @@ git pull originEnc master
 
         # ================================================================================
         option1 = "Delete remote copy and push local:"
-        program_1_py = f"""
-from machineconfig.scripts.python.helpers.repo_sync_helpers import delete_remote_repo_copy_and_push_local as func
-func(remote_repo=r'{str(repo_remote_root)}', local_repo=r'{str(repo_local_root)}', cloud=r'{cloud_resolved}')
-"""
-        shell_file_1 = get_shell_file_executing_python_script(python_script=program_1_py, ve_path=str(Path.home().joinpath("code", "machineconfig", ".venv")))
+        def func2(remote_repo: str, local_repo: str, cloud: str):
+            from machineconfig.scripts.python.repos_helpers.sync import delete_remote_repo_copy_and_push_local
+            delete_remote_repo_copy_and_push_local(remote_repo=remote_repo, local_repo=local_repo, cloud=cloud)
+            return "done"
+        from machineconfig.utils.meta import function_to_script
+        program_1_py = function_to_script(func=func2, call_with_args=None, call_with_kwargs={"remote_repo": str(repo_remote_root), "local_repo": str(repo_local_root), "cloud": cloud_resolved})
+        shell_file_1 = get_shell_file_executing_python_script(python_script=program_1_py, ve_path=None, executable="uv run --with machineconfig")
         # ================================================================================
-
         option2 = "Delete local repo and replace it with remote copy:"
         program_2 = f"""
 rm -rfd {repo_local_root}
@@ -114,16 +114,15 @@ sudo chmod 600 $HOME/.ssh/*
 sudo chmod 700 $HOME/.ssh
 sudo chmod +x $HOME/dotfiles/scripts/linux -R
 """
-
         shell_file_2 = write_shell_script_to_file(shell_script=program_2)
-
         # ================================================================================
         option3 = "Inspect repos:"
-        program_3_py = f"""
-from machineconfig.scripts.python.helper.repo_sync_helpers import inspect_repos as func
-func(repo_local_root=r'{str(repo_local_root)}', repo_remote_root=r'{str(repo_remote_root)}')
-"""
-        shell_file_3 = get_shell_file_executing_python_script(python_script=program_3_py, ve_path=str(Path.home().joinpath("code", "machineconfig", ".venv")))
+        def func(repo_local_root: str, repo_remote_root: str):
+            from machineconfig.scripts.python.repos_helpers.sync import inspect_repos
+            inspect_repos(repo_local_root=repo_local_root, repo_remote_root=repo_remote_root)
+            return "done"
+        program_3_py = function_to_script(func=func, call_with_args=None, call_with_kwargs={"repo_local_root": str(repo_local_root), "repo_remote_root": str(repo_remote_root)})
+        shell_file_3 = get_shell_file_executing_python_script(python_script=program_3_py, ve_path=None, executable="uv run --with machineconfig")
         # ================================================================================
 
         option4 = "Remove problematic rclone file from repo and replace with remote:"

machineconfig-5.60/src/machineconfig/setup_windows/web_shortcuts/interactive.ps1

@@ -0,0 +1,31 @@
+
+
+iex (iwr "https://raw.githubusercontent.com/thisismygitrepo/machineconfig/main/src/machineconfig/setup_windows/uv.ps1").Content
+function devops {
+    & "$HOME\.local\bin\uv.exe" run --python 3.14 --with machineconfig devops $args
+}
+
+function cloud {
+    & "$HOME\.local\bin\uv.exe" run --python 3.14 --with machineconfig cloud $args
+}
+
+function croshell {
+    & "$HOME\.local\bin\uv.exe" run --python 3.14 --with machineconfig croshell $args
+}
+
+function agents {
+    & "$HOME\.local\bin\uv.exe" run --python 3.14 --with machineconfig agents $args
+}
+
+function fire {
+    & "$HOME\.local\bin\uv.exe" run --python 3.14 --with machineconfig fire $args
+}
+
+function ftpx {
+    & "$HOME\.local\bin\uv.exe" run --python 3.14 --with machineconfig ftpx $args
+}
+
+function sessions {
+    & "$HOME\.local\bin\uv.exe" run --python 3.14 --with machineconfig sessions $args
+}
+

{machineconfig-5.58 → machineconfig-5.60}/src/machineconfig/utils/code.py

@@ -10,14 +10,16 @@ from machineconfig.utils.ve import get_ve_activate_line
 from machineconfig.utils.path_extended import PathExtended
 
 
-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}"""
-    else:
-        exec_line = f"""python -m fire {python_file} {func}"""
+def get_shell_script_executing_python_file(python_file: str, func: Optional[str], ve_path: Optional[str], executable: Optional[str], strict_execution: bool = True):
+    if executable is None: exe_resolved = "python"
+    else: exe_resolved = executable
+    if func is None: exec_line = f"""{exe_resolved} {python_file}"""
+    else: exec_line = f"""{exe_resolved} -m fire {python_file} {func}"""
+    if ve_path is None: ve_activate_line = ""
+    else: ve_activate_line = get_ve_activate_line(ve_path)
     shell_script = f"""
 echo "Executing `{exec_line}`"
-{get_ve_activate_line(ve_path)}
+{ve_activate_line}
 {exec_line}
 deactivate || true
 """
@@ -31,7 +33,7 @@ deactivate || true
     return shell_script
 
 
-def get_shell_file_executing_python_script(python_script: str, ve_path: str, verbose: bool = True):
+def get_shell_file_executing_python_script(python_script: str, ve_path: Optional[str], executable: Optional[str], verbose: bool = True):
     if verbose:
         python_script = f"""
 code = r'''{python_script}'''
@@ -47,7 +49,7 @@ except ImportError:
     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_script = get_shell_script_executing_python_file(python_file=str(python_file), func=None, ve_path=ve_path, executable=executable)
     shell_file = write_shell_script_to_file(shell_script)
     return shell_file
 
@@ -132,14 +134,3 @@ def run_shell_script(script: str, display_script: bool = True, clean_env: bool =
     temp_script_path.unlink(missing_ok=True)
     console.print(f"🗑️  [blue]Temporary script deleted:[/blue] [green]{temp_script_path}[/green]")
     return proc
-
-
-# def run_command(command: str, description: str) -> bool:
-#     """Execute a shell command and return success status."""
-#     console.print(f"\n🔧 {description}", style="bold cyan")
-#     try:
-#         result = subprocess.run(command, shell=True, check=True, capture_output=False)
-#         return result.returncode == 0
-#     except subprocess.CalledProcessError as e:
-#         console.print(f"❌ Error executing command: {e}", style="bold red")
-#         return False

machineconfig-5.60/src/machineconfig/utils/meta.py

@@ -0,0 +1,166 @@
+"""Metaprogramming utilities for analyzing and serializing Python functions."""
+
+import ast
+import inspect
+import textwrap
+from types import FunctionType, ModuleType
+from typing import Any
+
+
+def function_to_script(func: FunctionType, call_with_args: tuple[Any, ...] | None = None, call_with_kwargs: dict[str, Any] | None = None) -> str:
+    """Convert a function to a standalone executable Python script.
+    
+    This function analyzes a given function and generates a complete Python script
+    that includes all necessary imports, global variables, the function definition,
+    and optionally a function call.
+    
+    Args:
+        func: The function to convert to a script
+        call_with_args: Optional tuple of positional arguments to call the function with
+        call_with_kwargs: Optional dict of keyword arguments to call the function with
+    
+    Returns:
+        A complete Python script as a string that can be executed independently
+    
+    Raises:
+        ValueError: If the function cannot be inspected or analyzed
+    """
+    if not callable(func) or not hasattr(func, '__code__'):
+        raise ValueError(f"Expected a function, got {type(func)}")
+    
+    call_with_args = call_with_args or ()
+    call_with_kwargs = call_with_kwargs or {}
+    
+    imports = _extract_imports(func)
+    globals_needed = _extract_globals(func)
+    source_code = _get_function_source(func)
+    call_statement = _generate_call_statement(func, call_with_args, call_with_kwargs)
+    
+    script_parts: list[str] = []
+    
+    if imports:
+        script_parts.append(imports)
+        script_parts.append("")
+    
+    if globals_needed:
+        script_parts.append(globals_needed)
+        script_parts.append("")
+    
+    script_parts.append(source_code)
+    script_parts.append("")
+    
+    if call_statement:
+        script_parts.append("")
+        script_parts.append("if __name__ == '__main__':")
+        script_parts.append(f"    {call_statement}")
+    
+    return "\n".join(script_parts)
+
+
+def _get_function_source(func: FunctionType) -> str:
+    """Extract the source code of a function."""
+    try:
+        source = inspect.getsource(func)
+        return textwrap.dedent(source)
+    except (OSError, TypeError) as e:
+        raise ValueError(f"Cannot get source code for function {func.__name__}: {e}") from e
+
+
+def _extract_imports(func: FunctionType) -> str:
+    """Extract all import statements needed by the function."""
+    import_statements: set[str] = set()
+    
+    source = _get_function_source(func)
+    func_globals = func.__globals__
+    
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as e:
+        raise ValueError(f"Failed to parse function source: {e}") from e
+    
+    used_names: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name):
+            used_names.add(node.id)
+        elif isinstance(node, ast.Attribute):
+            if isinstance(node.value, ast.Name):
+                used_names.add(node.value.id)
+    
+    for name in used_names:
+        if name in func_globals:
+            obj = func_globals[name]
+            
+            if isinstance(obj, ModuleType):
+                module_name = obj.__name__
+                if name == module_name.split('.')[-1]:
+                    import_statements.add(f"import {module_name}")
+                else:
+                    import_statements.add(f"import {module_name} as {name}")
+            
+            elif hasattr(obj, '__module__') and obj.__module__ != '__main__':
+                try:
+                    module_name = obj.__module__
+                    obj_name = obj.__name__ if hasattr(obj, '__name__') else name
+                    
+                    if module_name and module_name != 'builtins':
+                        if obj_name == name:
+                            import_statements.add(f"from {module_name} import {obj_name}")
+                        else:
+                            import_statements.add(f"from {module_name} import {obj_name} as {name}")
+                except AttributeError:
+                    pass
+    
+    return "\n".join(sorted(import_statements))
+
+
+def _extract_globals(func: FunctionType) -> str:
+    """Extract global variables needed by the function."""
+    global_assignments: list[str] = []
+    
+    source = _get_function_source(func)
+    func_globals = func.__globals__
+    
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as e:
+        raise ValueError(f"Failed to parse function source: {e}") from e
+    
+    used_names: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Name):
+            used_names.add(node.id)
+        elif isinstance(node, ast.Attribute):
+            if isinstance(node.value, ast.Name):
+                used_names.add(node.value.id)
+    
+    for name in used_names:
+        if name in func_globals:
+            obj = func_globals[name]
+            
+            if not isinstance(obj, (ModuleType, FunctionType, type)):
+                if not (hasattr(obj, '__module__') and hasattr(obj, '__name__')):
+                    try:
+                        repr_str = repr(obj)
+                        if len(repr_str) < 1000 and '\n' not in repr_str:
+                            global_assignments.append(f"{name} = {repr_str}")
+                    except Exception:
+                        global_assignments.append(f"# Warning: Could not serialize global variable '{name}'")
+    
+    return "\n".join(global_assignments)
+
+
+def _generate_call_statement(func: FunctionType, args: tuple[Any, ...], kwargs: dict[str, Any]) -> str:
+    """Generate a function call statement with the given arguments."""
+    if not args and not kwargs:
+        return f"{func.__name__}()"
+    
+    arg_parts: list[str] = []
+    
+    for arg in args:
+        arg_parts.append(repr(arg))
+    
+    for key, value in kwargs.items():
+        arg_parts.append(f"{key}={repr(value)}")
+    
+    args_str = ", ".join(arg_parts)
+    return f"{func.__name__}({args_str})"