machineconfig 7.64__py3-none-any.whl → 7.83__py3-none-any.whl

machineconfig/scripts/python/helpers_repos/count_lines.py

@@ -5,7 +5,9 @@ from collections import defaultdict
 from datetime import datetime
 
 from pathlib import Path
+from rich.console import Console
 from rich.progress import track
+from rich.table import Table
 import typer
 
 
@@ -14,9 +16,6 @@ if TYPE_CHECKING:
     import polars as pl
 
 
-app = typer.Typer()
-
-
 def count_lines_in_commit(commit: "Any") -> int:
     _total_lines = 0
     for _file in commit.stats.files:
@@ -81,7 +80,10 @@ def get_default_branch(repo: Repo) -> str:
             return repo.head.reference.name  # If neither exists, get the branch the HEAD is pointing to
 
 
-@app.command()
+
+console = Console()
+
+
 def count_historical(repo_path: Annotated[str, typer.Argument(..., help="Path to the git repository")]):
     """Count total historical lines of Python code in the repository."""
     print(f"Analyzing repository: {repo_path}")
@@ -89,7 +91,7 @@ def count_historical(repo_path: Annotated[str, typer.Argument(..., help="Path to
     print(f"\nTotal historical lines of Python code: {total_loc}")
 
 
-@app.command()
+
 def analyze_over_time(repo_path: Annotated[str, typer.Argument(..., help="Path to the git repository")]):
     """Analyze a git repository to track Python code size over time with visualization."""
     repo: Repo = Repo(repo_path)
@@ -170,8 +172,14 @@ def analyze_over_time(repo_path: Annotated[str, typer.Argument(..., help="Path t
     html_path = plot_dir.joinpath("code_size_evolution.html")
     png_path = plot_dir.joinpath("code_size_evolution.png")
 
-    fig.write_html(html_path, include_plotlyjs="cdn")
-    fig.write_image(png_path, width=1200, height=700, scale=2)
+    try:
+        fig.write_html(html_path, include_plotlyjs="cdn")
+    except Exception as e:
+        print(f"❌ Error saving HTML plot: {str(e)}")
+    try:
+        fig.write_image(png_path, width=1200, height=700, scale=2)
+    except Exception as e:
+        print(f"❌ Error saving PNG plot: {str(e)}")
 
     print(f"🖼️ Interactive plot saved as {html_path}")
     print(f"🖼️ Static image saved as {png_path}")
@@ -232,8 +240,17 @@ def _print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exc
         file_count: int = len(df)
 
         # Print the DataFrame
-        print("\n📊 Python Files Line Count (sorted max to min):")
-        print(df)
+        console.print("\n📊 Python Files Line Count (sorted max to min):")
+
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("#", justify="right")
+        table.add_column("File", overflow="fold")
+        table.add_column("Lines", justify="right")
+
+        for idx, row in enumerate(df.iter_rows(named=True), 1):
+            table.add_row(str(idx), row["filename"], f"{row['lines']:,}")
+
+        console.print(table)
         print(f"\n📁 Total Python files: {file_count}")
         print(f"📝 Total lines of Python code: {total_lines:,}")
 
@@ -335,7 +352,7 @@ def _print_python_files_by_size_impl(repo_path: str) -> "Union[pl.DataFrame, Exc
         return Exception(f"❌ Error analyzing repository: {str(e)}")
 
 
-@app.command()
+
 def print_python_files_by_size(repo_path: Annotated[str, typer.Argument(..., help="Path to the git repository")]):
     """Print Python files sorted by size with visualizations."""
     result = _print_python_files_by_size_impl(repo_path)
@@ -344,5 +361,17 @@ def print_python_files_by_size(repo_path: Annotated[str, typer.Argument(..., hel
         return
 
 
+def get_app():
+    app = typer.Typer()
+    app.command(name="count-historical", no_args_is_help=True, help="[c] Count lines of code in a git repository")(count_historical)
+    app.command(name="c", hidden=True, no_args_is_help=True, help="Alias for count-historical")(count_historical)
+    app.command(name="analyze-over-time", no_args_is_help=True, help="[a] Analyze code size over time in a git repository")(analyze_over_time)
+    app.command(name="a", hidden=True, no_args_is_help=True, help="Alias for analyze-over-time")(analyze_over_time)
+    app.command(name="print-python-files-by-size", no_args_is_help=True, help="[p] Print Python files by size in a git repository")(print_python_files_by_size)
+    app.command(name="p", hidden=True, no_args_is_help=True, help="Alias for print-python-files-by-size")(print_python_files_by_size)
+    return app
+
+
 if __name__ == "__main__":
-    app()
+    get_app()()
+

machineconfig/scripts/python/helpers_repos/count_lines_frontend.py

@@ -8,7 +8,7 @@ def analyze_repo_development(repo_path: Annotated[str, typer.Argument(..., help=
     from pathlib import Path
     count_lines_path = Path(count_lines.__file__)
     # --project $HOME/code/ machineconfig --group plot
-    cmd = f"""uv run --python 3.14 --with "machineconfig[plot]>=7.64" {count_lines_path} analyze-over-time {repo_path}"""
+    cmd = f"""uv run --python 3.14 --with "machineconfig[plot]>=7.83" {count_lines_path} analyze-over-time {repo_path}"""
     from machineconfig.utils.code import run_shell_script
     run_shell_script(cmd)
 

machineconfig/scripts/python/helpers_utils/download.py

@@ -2,6 +2,7 @@
 
 from typing import Annotated, Optional
 import typer
+from pathlib import Path
 
 
 def download(
@@ -12,11 +13,10 @@ def download(
 ) -> Optional["Path"]:
 
     import subprocess
-    from pathlib import Path
     from urllib.parse import parse_qs, unquote, urlparse
     from requests import Response
     import requests
-
+    from pathlib import Path
     if url is None:
         typer.echo("❌ Error: URL is required.", err=True)
         return None
@@ -147,5 +147,6 @@ def download(
 
     return result_path.resolve()
 
+
 if __name__ == "__main__":
-    from pathlib import Path
+    pass

machineconfig/scripts/python/helpers_utils/path.py

@@ -2,58 +2,92 @@
 
 
 import typer
+from typing import Optional, Annotated, Literal, TypedDict
 
-from typing import Optional
-from pathlib import Path
-from typing import Annotated, Literal, TypedDict
 
-
-def path():
+def tui_env(which: Annotated[Literal["PATH", "p", "ENV", "e"], typer.Argument(help="Which environment variable to display.")] = "ENV") -> None:
     """📚 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")
+    match which:
+        case "PATH" | "p":
+            path = Path(navigator.__file__).resolve().parent.joinpath("path_manager_tui.py")
+        case "ENV" | "e":
+            path = Path(navigator.__file__).resolve().parent.joinpath("env_manager_tui.py")
     from machineconfig.utils.code import run_shell_script, get_uv_command_executing_python_script
     uv_with = ["textual"]
     uv_project_dir = None
     if not Path.home().joinpath("code/machineconfig").exists():
-        uv_with.append("machineconfig>=7.64")
+        uv_with.append("machineconfig>=7.83")
     else:
         uv_project_dir = str(Path.home().joinpath("code/machineconfig"))
     run_shell_script(get_uv_command_executing_python_script(python_script=path.read_text(encoding="utf-8"), uv_with=uv_with, uv_project_dir=uv_project_dir)[0])
 
 
-def init_project(python: Annotated[Literal["3.13", "3.14"], typer.Option("--python", "-p", help="Python version for the uv virtual environment.")]= "3.13") -> None:
-    _ = python
-    repo_root = Path.cwd()
-    if not (repo_root / "pyproject.toml").exists():
-        typer.echo("❌ Error: pyproject.toml not found.", err=True)
-        raise typer.Exit(code=1)
-    print("Adding group `plot` with common data science and plotting packages...")
-    script = """
-uv add --group plot \
-    # Data & computation
-    numpy pandas polars duckdb-engine python-magic \
-    # Plotting / visualization
-    matplotlib plotly kaleido \
-    # Notebooks / interactive
-    ipython ipykernel jupyterlab nbformat marimo \
-    # Code analysis / type checking / linting
-    mypy pyright ruff pylint pyrefly \
-    # Packaging / build / dev
-    cleanpy \
-    # CLI / debugging / utilities
-    ipdb pudb \
-    # Type hints for packages
-    types-python-dateutil types-pyyaml types-requests types-tqdm \
-    types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3 \
-
+def init_project(
+                 name: Annotated[Optional[str], typer.Option("--name", "-n", help="Name of the project.")]= None,
+                 tmp_directory: Annotated[bool, typer.Option("--tmp-directory/--no-tmp-directory", "-t/-nt", help="Use a temporary directory for the project initialization.")]= False,
+                 python: Annotated[Literal["3.13", "3.14"], typer.Option("--python", "-p", help="Python version for the uv virtual environment.")]= "3.13",
+                 packages: Annotated[Optional[str], typer.Option("--packages", "-p", help="Additional packages to include in the uv virtual environment.")]= None,
+                 group: Annotated[Optional[str], typer.Option("--group", "-g", help="Group name for the packages.")]= "plot",
+                 types_packages: Annotated[bool, typer.Option("--types-packages/--no-types-packages", "-T/-NT", help="Include types packages for better type hinting.")]= True,
+                    linting_debug_packages: Annotated[bool, typer.Option("--linting-debug-packages/--no-linting-debug-packages", "-L/-NL", help="Include linting and debugging packages.")]= True,
+                    ia_packages: Annotated[bool, typer.Option("--ia-packages/--no-ia-packages", "-I/-NI", help="Include interactive and IA packages.")]= True,
+                    plot_packages: Annotated[bool, typer.Option("--plot-packages/--no-plot-packages", "-P/-NP", help="Include plotting packages.")]= True,
+                    data_packages: Annotated[bool, typer.Option("--data-packages/--no-data-packages", "-D/-ND", help="Include data manipulation packages.")]= True,
+                 ) -> None:
+    if packages is not None:
+        packages_add_line = f"uv add {packages}"
+    else:
+        packages_add_line = ""
+    from pathlib import Path
+    if not tmp_directory:
+        repo_root = Path.cwd()
+        if not (repo_root / "pyproject.toml").exists():
+            typer.echo("❌ Error: pyproject.toml not found.", err=True)
+            raise typer.Exit(code=1)
+        starting_code = ""
+    else:
+        if name is not None:
+            from machineconfig.utils.accessories import randstr
+            repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{name}")
+        else:
+            from machineconfig.utils.accessories import randstr
+            repo_root = Path.home().joinpath(f"tmp_results/tmp_projects/{randstr(6)}")
+        repo_root.mkdir(parents=True, exist_ok=True)
+        print(f"Using temporary directory for project initialization: {repo_root}")
+        starting_code = f"""
+cd {repo_root}
+uv init --python {python}
+uv venv
+"""
+    print(f"Adding group `{group}` with common data science and plotting packages...")
+    total_packages: list[str] = []
+
+    if types_packages:
+        total_packages.append("types-python-dateutil types-pyyaml types-requests types-tqdm types-mysqlclient types-paramiko types-pytz types-sqlalchemy types-toml types-urllib3")
+    if linting_debug_packages:
+        total_packages.append("mypy pyright ruff pylint pyrefly cleanpy ipdb pudb")
+    if ia_packages:
+        total_packages.append("ipython ipykernel jupyterlab nbformat marimo")
+    if plot_packages:
+        total_packages.append("python-magic matplotlib plotly kaleido")
+    if data_packages:
+        total_packages.append("numpy pandas polars duckdb-engine sqlalchemy  psycopg2-binary pyarrow tqdm openpyxl")
+    from machineconfig.utils.ve import get_ve_activate_line
+    script = f"""
+{starting_code}
+{packages_add_line}
+uv add --group {group} {" ".join(total_packages)}
+{get_ve_activate_line(ve_root=str(repo_root.joinpath(".venv")))}
+ls
 """
-    from machineconfig.utils.code import run_shell_script
-    run_shell_script(script)
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(script)
 
 
 def edit_file_with_hx(path: Annotated[Optional[str], typer.Argument(..., help="The root directory of the project to edit, or a file path.")] = None) -> None:
+    from pathlib import Path
     if path is None:
         root_path = Path.cwd()
         print(f"No path provided. Using current working directory: {root_path}")
@@ -82,6 +116,13 @@ class MachineSpecs(TypedDict):
     system: str
     distro: str
     home_dir: str
+    hostname: str
+    release: str
+    version: str
+    machine: str
+    processor: str
+    python_version: str
+    user: str
 
 
 def get_machine_specs() -> MachineSpecs:
@@ -90,11 +131,21 @@ def get_machine_specs() -> MachineSpecs:
     UV_RUN_CMD = "$HOME/.local/bin/uv run" if platform.system() != "Windows" else """& "$env:USERPROFILE/.local/bin/uv" run"""
     command = f"""{UV_RUN_CMD} --with distro python -c "import distro; print(distro.name(pretty=True))" """
     import subprocess
+    from pathlib import Path
+    import socket
+    import os
     distro = subprocess.run(command, shell=True, capture_output=True, text=True).stdout.strip()
     specs: MachineSpecs = {
         "system": platform.system(),
         "distro": distro,
         "home_dir": str(Path.home()),
+        "hostname": socket.gethostname(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor() or "Unknown",
+        "python_version": platform.python_version(),
+        "user": os.getenv("USER") or os.getenv("USERNAME") or "Unknown",
     }
     print(specs)
     from machineconfig.utils.source_of_truth import CONFIG_ROOT
@@ -104,3 +155,5 @@ def get_machine_specs() -> MachineSpecs:
     path.write_text(json.dumps(specs, indent=4), encoding="utf-8")
     return specs
 
+if __name__ == "__main__":
+    get_machine_specs()

machineconfig/scripts/python/interactive.py

@@ -111,7 +111,7 @@ def execute_installations(selected_options: list[str]) -> None:
             console.print(Panel("⚡ [bold bright_yellow]CLI APPLICATIONS[/bold bright_yellow]\n[italic]Command-line tools installation[/italic]", border_style="bright_yellow"))
             console.print("🔧 Installing CLI applications", style="bold cyan")
             try:
-                from machineconfig.utils.installer_utils.installer_cli import main as devops_devapps_install_main
+                from machineconfig.utils.installer_utils.installer_cli import main_installer_cli as devops_devapps_install_main
                 devops_devapps_install_main(group=True, which=maybe_a_group, interactive=False)
                 console.print("✅ CLI applications installed successfully", style="bold green")
             except Exception as e:

machineconfig/scripts/python/{machineconfig.py → mcfg_entry.py}

@@ -57,3 +57,7 @@ def get_app():
 def main():
     app = get_app()
     app()
+
+
+if __name__ == "__main__":
+    main()

machineconfig/scripts/python/msearch.py

@@ -1,21 +1,70 @@
 
 import typer
+from typing import Annotated
 
 
-def machineconfig_find():
+def machineconfig_search(
+        directory: Annotated[str, typer.Option(..., "--directory", "-d", help="The directory to search")] = ".",
+        ast: Annotated[bool, typer.Option(..., "--ast", "-a", help="The abstract syntax tree search/ tree sitter search of symbols")] = False,
+        symantic: Annotated[bool, typer.Option(..., "--symantic", "-s", help="The symantic search of symbols")] = False,
+        extension: Annotated[str, typer.Option(..., "--extension", "-e", help="File extension to filter by (e.g., .py, .js)")] = "",
+        file: Annotated[bool, typer.Option(..., "--file", "-f", help="File search using fzf")] = False,
+        no_dotfiles: Annotated[bool, typer.Option(..., "--no-dotfiles", "-d", help="Exclude dotfiles from search")] = False,
+        rga: Annotated[bool, typer.Option(..., "--rga", "-a", help="Use ripgrep-all for searching instead of ripgrep")] = False,
+        install_dependencies: Annotated[bool, typer.Option(..., "--install-dependencies", "-p", help="Install required dependencies if missing")] = False
+        ):
+    if install_dependencies:
+        from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+        install_if_missing("fzf")
+        install_if_missing("bat")
+        install_if_missing("fd")
+        install_if_missing("rg")  # ripgrep
+        install_if_missing("rga")  # ripgrep-all
+        # install_if_missing("tree-sitter-cli")
+        return
+    if symantic:
+        script = ""
+        for an_ex in extension.split(","):
+            script = script + f"""\nparse *.{an_ex} """
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=script)
+        return
+    if ast:
+        from machineconfig.scripts.python.helpers.ast_search import get_repo_symbols
+        symbols = get_repo_symbols(directory)
+        from machineconfig.utils.options import choose_from_options
+        try:
+            res = choose_from_options(options=symbols, msg="Select a symbol to search for:", fzf=True, multi=False)
+            from rich import print_json
+            import json
+            res_json = json.dumps(res, indent=4)
+            print_json(res_json)
+            return None
+        except Exception as e:
+            print(f"❌ Error during selection: {e}")
+            return None
+    if file:
+        script = """fzf --ansi --preview-window 'right:60%' --preview 'bat --color=always --style=numbers,grid,header --line-range :300 {}' """
+        if no_dotfiles:
+            script = "fd | " + script
+        from machineconfig.utils.code import run_shell_script
+        run_shell_script(script=script)
+        return
     from machineconfig.scripts.python.helpers_msearch import FZFG_LINUX_PATH, FZFG_WINDOWS_PATH
     import platform
-    if platform.system() == "Linux":
-        script_path = FZFG_LINUX_PATH
+    if platform.system() == "Linux" or platform.system() == "Darwin":
+        script = FZFG_LINUX_PATH.read_text(encoding="utf-8")
     elif platform.system() == "Windows":
-        script_path = FZFG_WINDOWS_PATH
+        script = FZFG_WINDOWS_PATH.read_text(encoding="utf-8")
     else:
         raise RuntimeError("Unsupported platform")
+    if rga:
+        script = script.replace("rg ", "rga ").replace("ripgrep", "ripgrep-all")
     from machineconfig.utils.code import exit_then_run_shell_script
-    exit_then_run_shell_script(script=script_path.read_text(encoding="utf-8"), strict=False)
+    exit_then_run_shell_script(script=script, strict=False)
 
 
 def main():
     app = typer.Typer(add_completion=False, no_args_is_help=True)
-    app.command(name="msearch", help="machineconfig search helper", no_args_is_help=False)(machineconfig_find)
+    app.command(name="msearch", help="machineconfig search helper", no_args_is_help=False)(machineconfig_search)
     app()

machineconfig/scripts/python/nw/address.py

@@ -0,0 +1,132 @@
+
+from typing import cast, Optional
+
+
+def get_all_ipv4_addresses() -> list[tuple[str, str]]:
+    import psutil
+    import socket
+    result: list[tuple[str, str]] = []
+    for iface, addrs in psutil.net_if_addrs().items():
+        for addr in addrs:
+            if addr.family == socket.AF_INET:
+                ip = addr.address
+                result.append((iface, ip))
+    return result
+
+
+def select_lan_ipv4(prefer_vpn: bool) -> Optional[str]:
+    """
+    Choose the best 'real LAN' IPv4:
+      - Excludes loopback/link-local and (by default) VPN/tunnel/container ifaces
+      - Prefers physical-looking ifaces (eth/en*/wlan/wl*)
+      - Prefers RFC1918 LANs: 192.168/16 > 10/8 > 172.16/12
+      - Requires interface is UP
+    Set prefer_vpn=True to allow tunnel/VPN ifaces to compete.
+    """
+
+    import ipaddress
+    import re
+    from collections.abc import Sequence
+    import psutil
+
+    # Down-rank or exclude: tunnels/VPNs/bridges/containers (add your own if needed)
+    VIRTUAL_IFACE_PAT = re.compile(
+        r"^(?:lo|loopback|docker\d*|br-.*|veth.*|virbr.*|bridge.*|"
+        r"vboxnet.*|vmnet.*|zt.*|ham.*|tailscale.*|wg\d*|utun\d*|llw\d*|awdl\d*|"
+        r"tun\d*|tap\d*|cloudflarewarp.*|warp.*)$",
+        re.IGNORECASE,
+    )
+
+    # Light preference for names that look like real NICs
+    PHYSICAL_IFACE_PAT = re.compile(
+        r"^(?:eth\d*|en\d*|enp.*|ens.*|eno.*|wlan\d*|wl.*|.*wifi.*|.*ethernet.*)$",
+        re.IGNORECASE,
+    )
+
+    # Known noisy CIDRs to avoid
+    NOISY_NETS: list[ipaddress.IPv4Network] = [
+        ipaddress.IPv4Network("100.64.0.0/10"),   # CGNAT (Tailscale/others)
+        ipaddress.IPv4Network("172.17.0.0/16"),   # docker0 default
+        ipaddress.IPv4Network("172.18.0.0/16"),
+        ipaddress.IPv4Network("172.19.0.0/16"),
+        ipaddress.IPv4Network("192.168.49.0/24"), # minikube default
+        ipaddress.IPv4Network("10.0.2.0/24"),     # VirtualBox NAT
+    ]
+
+    def _in_any(ip: ipaddress.IPv4Address, nets: Sequence[ipaddress.IPv4Network]) -> bool:
+        return any(ip in n for n in nets)
+
+    stats = psutil.net_if_stats()
+    best = None
+    best_score = -10**9
+    import socket
+    for iface, addrs in psutil.net_if_addrs().items():
+        st = stats.get(iface)
+        if not st or not st.isup:
+            continue
+
+        for a in addrs:
+            if a.family != socket.AF_INET or not a.address:
+                continue
+
+            ip_str = a.address
+            try:
+                ip = cast(ipaddress.IPv4Address, ipaddress.ip_address(ip_str))
+            except ValueError:
+                continue
+
+            # Exclude unusable classes
+            if ip.is_loopback or ip.is_link_local:  # 127.0.0.0/8, 169.254.0.0/16
+                continue
+
+            # Hard filter: if it looks virtual and we don't prefer VPNs, skip it
+            if not prefer_vpn and VIRTUAL_IFACE_PAT.match(iface):
+                continue
+
+            # Hard filter: known noisy subnets (docker, cgnat, etc.)
+            if _in_any(ip, NOISY_NETS) and not prefer_vpn:
+                continue
+
+            # Base score
+            score = 0
+
+            # Prefer physical-looking names
+            if PHYSICAL_IFACE_PAT.match(iface):
+                score += 200
+
+            # Broadcast present usually means L2 LAN (not point-to-point)
+            # (psutil puts it on the same entry as .broadcast)
+            if getattr(a, "broadcast", None):
+                score += 100
+
+            # Prefer private RFC1918; rank families
+            if ip.is_private:
+                # Order: 192.168.x.x > 10.x.x.x > 172.16-31.x.x
+                ip_net = ipaddress.IPv4Network((ip, 32), strict=False)
+                if ipaddress.IPv4Network("192.168.0.0/16").supernet_of(ip_net):
+                    score += 90
+                elif ipaddress.IPv4Network("10.0.0.0/8").supernet_of(ip_net):
+                    score += 70
+                elif ipaddress.IPv4Network("172.16.0.0/12").supernet_of(ip_net):
+                    score += 50
+            else:
+                # Public on a NIC is unusual for a home/office LAN
+                score -= 50
+
+            # Slight nudge by interface speed if known (>0 means psutil knows it)
+            # (Many tunnels report 0)
+            if getattr(st, "speed", 0) > 0:
+                score += 20
+
+            # Deterministic tie-breaker: prefer shorter iface name (eth0 over eth10)
+            score -= len(iface) * 0.01
+
+            if score > best_score:
+                best_score = score
+                best = ip_str
+
+    return best
+
+
+if __name__ == "__main__":
+    print(select_lan_ipv4(False) or "No LAN IPv4 found")

machineconfig/scripts/python/nw/devops_add_ssh_key.py

@@ -137,11 +137,14 @@ def main(pub_path: Annotated[Optional[str], typer.Argument(..., help="Path to th
     console.print(Panel("🚀 SSH KEY AUTHORIZATION READY\nRun the generated script to apply changes", box=box.DOUBLE_EDGE, title_align="left"))
     from machineconfig.utils.code import run_shell_script
     run_shell_script(script=program)
-    import socket
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.connect(('8.8.8.8', 80))
-    local_ip_v4 = s.getsockname()[0]
-    s.close()
+
+    import machineconfig.scripts.python.nw.address as helper
+    res = helper.select_lan_ipv4(prefer_vpn=False)
+    if res is None:
+        console.print(Panel("❌ ERROR: Could not determine local LAN IPv4 address", title="[bold red]Error[/bold red]", border_style="red"))
+        raise typer.Exit(code=1)
+    local_ip_v4 = res
+
     console.print(Panel(f"🌐 This computer is accessible at: {local_ip_v4}", title="[bold green]Network Info[/bold green]", border_style="green"))
     console.print(Panel("✅ SSH KEY AUTHORIZATION COMPLETED", box=box.DOUBLE_EDGE, title_align="left"))
 

machineconfig/scripts/python/terminal.py

@@ -1,5 +1,3 @@
-import subprocess
-# from machineconfig.utils.schemas.layouts.layout_types import LayoutConfig
 import typer
 from typing import Annotated
 
@@ -26,6 +24,7 @@ def choose_zellij_session(
         typer.Exit()
         return
     cmd = "zellij list-sessions"
+    import subprocess
     sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
     # filter out empty lines and keep raw lines (they contain creation info)
     sessions = [s for s in sessions if s.strip()]
@@ -63,6 +62,7 @@ def choose_zellij_session(
 
 def get_session_tabs() -> list[tuple[str, str]]:
     cmd = "zellij list-sessions"
+    import subprocess
     sessions: list[str] = subprocess.check_output(cmd, shell=True).decode().strip().split("\n")
     sessions = [strip_ansi_codes(s) for s in sessions]
     active_sessions = [s for s in sessions if "EXITED" not in s]

machineconfig/scripts/python/utils.py

@@ -1,11 +1,12 @@
 
 
 from machineconfig.scripts.python.helpers_devops.cli_utils import merge_pdfs, compress_pdf
-from machineconfig.scripts.python.helpers_utils.path import edit_file_with_hx, get_machine_specs, init_project, path
+from machineconfig.scripts.python.helpers_utils.path import edit_file_with_hx, get_machine_specs, init_project, tui_env
 from machineconfig.scripts.python.helpers_utils.download import download
 import typer
 from typing import Annotated
 
+
 def kill_process(
         # name: Annotated[Optional[str], typer.Option(..., "--name", "-n", help="Name of the process to kill")],
                 #  command: Annotated[str, typer.Option(..., "--command", "-c", help="Match by command line instead of process name")] = "",
@@ -29,27 +30,27 @@ def upgrade_packages():
 
 def get_app() -> typer.Typer:
     app = typer.Typer(help="🛠️ utilities operations", no_args_is_help=True, add_help_option=False, add_completion=False)
-    app.command(name="kill-process", no_args_is_help=False, help="[k] Choose a process to kill")(kill_process)
+    app.command(name="kill-process", no_args_is_help=False, help="⚔️ [k] Choose a process to kill")(kill_process)
     app.command(name="k", no_args_is_help=False, help="Choose a process to kill", hidden=True)(kill_process)
 
-    app.command("path", no_args_is_help=False, help="📚  [p] NAVIGATE PATH variable with TUI")(path)
-    app.command("p", no_args_is_help=False, help="NAVIGATE PATH variable with TUI", hidden=True)(path)
+    app.command("environment", no_args_is_help=False, help="📚 [v] NAVIGATE ENV/PATH variable with TUI")(tui_env)
+    app.command("v", no_args_is_help=False, help="NAVIGATE ENV/PATH variable with TUI", hidden=True)(tui_env)
 
-    app.command(name="upgrade-packages", no_args_is_help=False, help="[up] Upgrade project dependencies.")(upgrade_packages)
+    app.command(name="upgrade-packages", no_args_is_help=False, help="⬆️ [up] Upgrade project dependencies.")(upgrade_packages)
     app.command(name="up", no_args_is_help=False, hidden=True)(upgrade_packages)
 
-    app.command(name="download", no_args_is_help=True, help="[d] Download a file from a URL and optionally decompress it.")(download)
+    app.command(name="download", no_args_is_help=True, help="⬇️ [d] Download a file from a URL and optionally decompress it.")(download)
     app.command(name="d", no_args_is_help=True, hidden=True)(download)
-    app.command(name="get-machine-specs", no_args_is_help=False, help="[g] Get machine specifications.")(get_machine_specs)
+    app.command(name="get-machine-specs", no_args_is_help=False, help="💻 [g] Get machine specifications.")(get_machine_specs)
     app.command(name="g", no_args_is_help=False, hidden=True)(get_machine_specs)
-    app.command(name="init-project", no_args_is_help=False, help="[i] Initialize a project with a uv virtual environment and install dev packages.")(init_project)
+    app.command(name="init-project", no_args_is_help=False, help="🚀 [i] Initialize a project with a uv virtual environment and install dev packages.")(init_project)
     app.command(name="i", no_args_is_help=False, hidden=True)(init_project)
-    app.command(name="edit", no_args_is_help=False, help="[e] Open a file in the default editor.")(edit_file_with_hx)
+    app.command(name="edit", no_args_is_help=False, help="✏️ [e] Open a file in the default editor.")(edit_file_with_hx)
     app.command(name="e", no_args_is_help=False, hidden=True)(edit_file_with_hx)
 
-    app.command(name="pdf-merge", no_args_is_help=True, help="[pm] Merge two PDF files into one.")(merge_pdfs)
+    app.command(name="pdf-merge", no_args_is_help=True, help="📄 [pm] Merge two PDF files into one.")(merge_pdfs)
     app.command(name="pm", no_args_is_help=True, hidden=True)(merge_pdfs)
-    app.command(name="pdf-compress", no_args_is_help=True, help="[pc] Compress a PDF file.")(compress_pdf)
+    app.command(name="pdf-compress", no_args_is_help=True, help="📦 [pc] Compress a PDF file.")(compress_pdf)
     app.command(name="pc", no_args_is_help=True, hidden=True)(compress_pdf)
 
     # app.command(name="copy", no_args_is_help=True, help="[c] Copy files or directories.")(copy)

machineconfig/scripts/windows/mounts/mount_ssh.ps1

@@ -7,7 +7,7 @@ $user = ''
 $sharePath = ''
 $driveLetter = ''
 
-uv run --python 3.14 --with "machineconfig>=7.64" python -m machineconfig.scripts.python.mount_ssh
+uv run --python 3.14 --with "machineconfig>=7.83" python -m machineconfig.scripts.python.mount_ssh
 
 net use T: \\sshfs.kr\$user@$host.local
 # this worked: net use T: \\sshfs\alex@alex-p51s-5.local