machineconfig 7.98__py3-none-any.whl → 8.51__py3-none-any.whl

machineconfig/scripts/python/{helpers_network → helpers/helpers_network}/address.py

@@ -1,10 +1,54 @@
+from typing import Optional, TypedDict, cast
 
-from typing import cast, Optional
+
+class CountryFlag(TypedDict, total=False):
+    emoji: str
+    unicode: str
+
+
+class CountryCurrency(TypedDict, total=False):
+    code: str
+    symbol: str
+
+
+class Continent(TypedDict, total=False):
+    code: str
+    name: str
+
+
+class PublicIpInfo(TypedDict, total=True):
+    ip: str
+    hostname: str
+    city: str
+    region: str
+    country: str
+    country_name: str
+    country_flag: CountryFlag
+    country_flag_url: str
+    country_currency: CountryCurrency
+    continent: Continent
+    loc: str
+    org: str
+    postal: str
+    timezone: str
+
+
+def get_public_ip_address() -> PublicIpInfo:
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    import subprocess
+
+    install_if_missing("ipinfo")
+    result = subprocess.run(["ipinfo", "myip", "--json"], check=True, capture_output=True, text=True, encoding="utf-8")
+    import json
+
+    loaded_json: PublicIpInfo = json.loads(result.stdout)
+    return loaded_json
 
 
 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:
@@ -38,19 +82,16 @@ def select_lan_ipv4(prefer_vpn: bool) -> Optional[str]:
     )
 
     # 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,
-    )
+    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("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
+        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:
@@ -58,8 +99,9 @@ def select_lan_ipv4(prefer_vpn: bool) -> Optional[str]:
 
     stats = psutil.net_if_stats()
     best = None
-    best_score = -10**9
+    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:

machineconfig/scripts/python/helpers/helpers_network/address_switch.py

@@ -0,0 +1,78 @@
+import subprocess
+import time
+
+from machineconfig.scripts.python.helpers.helpers_network.address import get_public_ip_address
+
+
+def switch_public_ip_address(max_trials: int = 10, wait_seconds: float = 4.0) -> None:
+    print("🔁 Switching IP ... ")
+    from machineconfig.utils.installer_utils.installer_cli import install_if_missing
+    install_if_missing("warp-cli")
+
+    current_ip: str | None = None
+    try:
+        current_data = get_public_ip_address()
+        current_ip = current_data.get("ip")
+    except Exception as e:
+        print(f"⚠️ Could not get current IP: {e}")
+
+    print(f"Current IP: {current_ip}")
+
+    for attempt in range(1, max_trials + 1):
+        print(f"\n--- Attempt {attempt}/{max_trials} ---")
+
+        print("🔻 Deactivating current connection ... ")
+        # We use check=False because if it's already deleted it might return non-zero
+        subprocess.run(["warp-cli", "registration", "delete"], check=False)
+
+        print(f"😴 Sleeping for {wait_seconds} seconds ... ")
+        time.sleep(wait_seconds)
+
+        print("🔼 Registering new connection ... ")
+        res_reg = subprocess.run(["warp-cli", "registration", "new"], check=False)
+        if res_reg.returncode != 0:
+            print("⚠️ Registration failed, retrying loop...")
+            continue
+
+        print("🔗 Connecting ... ")
+        subprocess.run(["warp-cli", "connect"], check=False)
+
+        print(f"😴 Sleeping for {wait_seconds} seconds ... ")
+        time.sleep(wait_seconds)
+
+        print("🔍 Checking status of warp ... ")
+        subprocess.run(["warp-cli", "status"], check=False)
+
+        print("🔍 Checking new IP ... ")
+        new_ip: str | None = None
+        # Retry getting IP a few times before giving up on this connection attempt
+        for ip_check_attempt in range(5):
+            try:
+                new_data = get_public_ip_address()
+                new_ip = new_data["ip"]
+                if new_ip:
+                    break
+            except Exception as e:
+                print(f"⚠️ Error checking new IP (attempt {ip_check_attempt+1}/5): {e}")
+                time.sleep(wait_seconds)
+
+        if new_ip:
+            print(f"New IP: {new_ip}")
+
+            if current_ip and new_ip != current_ip:
+                print("✅ Done ... IP Changed.")
+                return
+            elif current_ip is None:
+                print("✅ Done ... IP obtained (was unknown).")
+                return
+            else:
+                print("❌ IP did not change.")
+        else:
+            print("⚠️ Could not retrieve new IP after multiple attempts.")
+
+    print("❌ Failed to switch IP after max trials.")
+
+
+if __name__ == "__main__":
+    switch_public_ip_address()
+

machineconfig/scripts/python/helpers/helpers_network/ftpx_impl.py

@@ -0,0 +1,276 @@
+"""Pure Python implementation for ftpx command - no typer dependencies."""
+
+from pathlib import Path
+from typing import Optional
+
+
+def ftpx(source: str, target: str, recursive: bool, zipFirst: bool, cloud: bool, overwrite_existing: bool) -> None:
+    """File transfer utility through SSH."""
+    if target == "wsl" or source == "wsl":
+        _handle_wsl_transfer(source=source, target=target, overwrite_existing=overwrite_existing)
+        return
+    elif source == "win" or target == "win":
+        _handle_win_transfer(source=source, target=target, overwrite_existing=overwrite_existing, windows_username=None)
+        return
+
+    from rich.console import Console
+    from rich.panel import Panel
+
+    console = Console()
+
+    console.print(
+        Panel(
+            "\n".join(["🚀 FTP File Transfer", "📋 Starting transfer process..."]),
+            title="Transfer Initialisation",
+            border_style="blue",
+            padding=(1, 2),
+        )
+    )
+
+    resolved_source, resolved_target, machine, source_is_remote = _resolve_paths(source=source, target=target)
+
+    from machineconfig.utils.accessories import pprint
+
+    pprint({"source": str(resolved_source), "target": str(resolved_target), "machine": machine}, "CLI Resolution")
+
+    ssh = _create_ssh_connection(machine=machine, console=console)
+
+    if cloud:
+        received_file = _handle_cloud_transfer(ssh=ssh, resolved_source=resolved_source, resolved_target=resolved_target, console=console)
+    else:
+        received_file = _handle_direct_transfer(
+            ssh=ssh,
+            resolved_source=resolved_source,
+            resolved_target=resolved_target,
+            source_is_remote=source_is_remote,
+            zipFirst=zipFirst,
+            recursive=recursive,
+            overwrite_existing=overwrite_existing,
+            console=console,
+        )
+    if source_is_remote and received_file is not None:
+        console.print(
+            Panel(
+                "\n".join(["📁 File Received", f"Parent: [cyan]{repr(received_file.parent)}[/cyan]", f"File: [cyan]{repr(received_file)}[/cyan]"]),
+                title="Transfer Result",
+                border_style="green",
+                padding=(1, 2),
+            )
+        )
+    console.print(Panel("File transfer process finished successfully", title="✅ Transfer Complete", border_style="green", padding=(1, 2)))
+
+
+def _handle_wsl_transfer(source: str, target: str, overwrite_existing: bool) -> None:
+    """Handle WSL transfer when inside Windows."""
+    from machineconfig.utils.ssh_utils.wsl import copy_when_inside_windows
+
+    if target == "wsl":
+        target_obj = Path(source).expanduser().absolute().relative_to(Path.home())
+        source_obj = target_obj
+    else:
+        source_obj = Path(target).expanduser().absolute().relative_to(Path.home())
+        target_obj = source_obj
+    copy_when_inside_windows(source_obj, target_obj, overwrite_existing)
+
+
+def _handle_win_transfer(source: str, target: str, overwrite_existing: bool, windows_username: str | None) -> None:
+    """Handle Windows transfer when inside WSL."""
+    from machineconfig.utils.ssh_utils.wsl import copy_when_inside_wsl
+
+    if source == "win":
+        source_obj = Path(target).expanduser().absolute().relative_to(Path.home())
+        target_obj = source_obj
+    else:
+        target_obj = Path(source).expanduser().absolute().relative_to(Path.home())
+        source_obj = target_obj
+    copy_when_inside_wsl(source_obj, target_obj, overwrite_existing, windows_username=windows_username)
+
+
+def _resolve_paths(source: str, target: str) -> tuple[Optional[str], Optional[str], str, bool]:
+    """Resolve source and target paths, determine machine and direction."""
+    from machineconfig.utils.path_extended import PathExtended
+    from machineconfig.scripts.python.helpers.helpers_cloud.helpers2 import ES
+
+    resolved_source: Optional[str] = None
+    resolved_target: Optional[str] = None
+    machine: str = ""
+    source_is_remote: bool = False
+
+    if ":" in source and (source[1] != ":" if len(source) > 1 else True):
+        source_is_remote = True
+        source_parts = source.split(":")
+        machine = source_parts[0]
+        if len(source_parts) > 1 and source_parts[1] == ES:
+            if target == ES:
+                raise ValueError(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Configuration Error
+┃    Cannot use expand symbol `{ES}` in both source and target
+┃    This creates a cyclical inference dependency
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+            else:
+                target_path_obj = PathExtended(target).expanduser().absolute()
+            resolved_source = target_path_obj.collapseuser().as_posix()
+            resolved_target = target
+        else:
+            resolved_source = ":".join(source.split(":")[1:])
+            if target == ES:
+                resolved_target = None
+            else:
+                resolved_target = PathExtended(target).expanduser().absolute().as_posix()
+
+    elif ":" in target and (target[1] != ":" if len(target) > 1 else True):
+        source_is_remote = False
+        target_parts = target.split(":")
+        machine = target_parts[0]
+        if len(target_parts) > 1 and target_parts[1] == ES:
+            if source == ES:
+                raise ValueError(f"""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Configuration Error
+┃    Cannot use expand symbol `{ES}` in both source and target
+┃    This creates a cyclical inference dependency
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+            else:
+                resolved_source = source
+            resolved_target = None
+        else:
+            resolved_target = ":".join(target.split(":")[1:])
+            if source == ES:
+                resolved_source = None
+            else:
+                resolved_source = PathExtended(source).expanduser().absolute().as_posix()
+    else:
+        raise ValueError("""
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+┃ ❌ Path Error
+┃    Either source or target must be a remote path
+┃    Format should be: machine:path
+┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━""")
+
+    return resolved_source, resolved_target, machine, source_is_remote
+
+
+def _create_ssh_connection(machine: str, console: "Console") -> "SSH":  # type: ignore[name-defined]
+    """Create SSH connection, handling authentication."""
+    from machineconfig.utils.ssh import SSH
+    from paramiko.ssh_exception import AuthenticationException  # type: ignore
+    from rich.panel import Panel
+
+    try:
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=None, port=22, enable_compression=True)
+    except AuthenticationException:
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "🔑 Authentication failed. Trying manual authentication...",
+                        "⚠️  Ensure that the username is provided correctly; only password prompts are handled here.",
+                    ]
+                ),
+                title="Authentication Required",
+                border_style="yellow",
+                padding=(1, 2),
+            )
+        )
+        import getpass
+
+        pwd = getpass.getpass()
+        ssh = SSH(host=rf"{machine}", username=None, hostname=None, ssh_key_path=None, password=pwd, port=22, enable_compression=True)
+
+    return ssh
+
+
+def _handle_cloud_transfer(
+    ssh: "SSH", resolved_source: Optional[str], resolved_target: Optional[str], console: "Console"
+) -> Optional["PathExtended"]:  # type: ignore[name-defined]
+    """Handle cloud transfer mode."""
+    from machineconfig.utils.path_extended import PathExtended
+    from rich.panel import Panel
+
+    console.print(Panel.fit("☁️  Cloud transfer mode — uploading from remote to cloud...", title="Cloud Upload", border_style="cyan"))
+    ssh.run_shell_cmd_on_remote(
+        command=f"cloud copy {resolved_source} :^",
+        verbose_output=True,
+        description="Uploading from remote to the cloud.",
+        strict_stderr=False,
+        strict_return_code=False,
+    )
+    console.print(Panel.fit("⬇️  Cloud transfer mode — downloading from cloud to local...", title="Cloud Download", border_style="cyan"))
+    ssh.run_shell_cmd_on_local(command=f"cloud copy :^ {resolved_target}")
+    return PathExtended(resolved_target)  # type: ignore
+
+
+def _handle_direct_transfer(
+    ssh: "SSH",
+    resolved_source: Optional[str],
+    resolved_target: Optional[str],
+    source_is_remote: bool,
+    zipFirst: bool,
+    recursive: bool,
+    overwrite_existing: bool,
+    console: "Console",
+) -> Optional["PathExtended"]:  # type: ignore[name-defined]
+    """Handle direct SSH transfer."""
+    from rich.panel import Panel
+
+    if source_is_remote:
+        if resolved_source is None:
+            print("❌ Path Error: Source must be a remote path (machine:path)")
+            return None
+        target_display = resolved_target or "<auto>"
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "📥 Transfer Mode: Remote → Local",
+                        f"Source: [cyan]{resolved_source}[/cyan]",
+                        f"Target: [cyan]{target_display}[/cyan]",
+                        f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                    ]
+                ),
+                title="Transfer Details",
+                border_style="cyan",
+                padding=(1, 2),
+            )
+        )
+        received_file = ssh.copy_to_here(source=resolved_source, target=resolved_target, compress_with_zip=zipFirst, recursive=recursive)
+    else:
+        assert resolved_source is not None, "❌ Path Error: Target must be a remote path (machine:path)"
+        target_display = resolved_target or "<auto>"
+        console.print(
+            Panel(
+                "\n".join(
+                    [
+                        "📤 Transfer Mode: Local → Remote",
+                        f"Source: [cyan]{resolved_source}[/cyan]",
+                        f"Target: [cyan]{target_display}[/cyan]",
+                        f"Options: {'ZIP compression' if zipFirst else 'No compression'}, {'Recursive' if recursive else 'Non-recursive'}",
+                    ]
+                ),
+                title="Transfer Details",
+                border_style="cyan",
+                padding=(1, 2),
+            )
+        )
+        received_file = ssh.copy_from_here(
+            source_path=resolved_source,
+            target_rel2home=resolved_target,
+            compress_with_zip=zipFirst,
+            recursive=recursive,
+            overwrite_existing=overwrite_existing,
+        )
+
+    return received_file
+
+
+if __name__ == "__main__":
+    from machineconfig.utils.ssh import SSH
+
+    _ = SSH
+    from machineconfig.utils.path_extended import PathExtended
+
+    _ = PathExtended
+    from rich.console import Console
+
+    _ = Console

machineconfig/scripts/python/{helpers_network → helpers/helpers_network}/mount_ssh.py

@@ -3,7 +3,7 @@
 from platform import system
 import subprocess
 from machineconfig.utils.ssh import SSH
-from machineconfig.utils.path_extended import PathExtended
+from pathlib import Path
 
 from machineconfig.utils.options import choose_ssh_host
 
@@ -35,7 +35,7 @@ def main():
 
     mount_point = input(f"📂 Enter the mount point directory (e.g., /mnt/network) [Default: ~/data/mount_ssh/{ssh.hostname}]: ")
     if mount_point == "":
-        mount_point = PathExtended.home().joinpath(rf"data/mount_ssh/{ssh.hostname}")
+        mount_point = Path.home().joinpath(rf"data/mount_ssh/{ssh.hostname}")
 
     print(f"\n📁 Mount Point: {mount_point}")
 

machineconfig/scripts/python/helpers/helpers_network/ssh_add_identity.py

@@ -0,0 +1,73 @@
+r"""ID
+
+On windows:
+
+$sshfile = "$env:USERPROFILE/.ssh/id_rsa"
+Set-Service ssh-agent -StartupType Manual  # allow the service to be started manually
+ssh-agent  # start the service
+ssh-add.exe $sshfile # add the key to the agent
+
+# copy ssh key:
+# This is the Windows equivalent of copy-ssh-id on Linux.
+# Just like the original function, it is a convenient way of doing two things in one go:
+# 1- copy a certain public key to the remote machine.
+#    scp ~/.ssh/id_rsa.pub $remote_user@$remote_host:~/.ssh/authorized_keys
+# 2- Store the value on the remote in a file called .ssh/authorized_keys
+#    ssh $remote_user@$remote_host "echo $public_key >> ~/.ssh/authorized_keys"
+# Idea from: https://www.chrisjhart.com/Windows-10-ssh-copy-id/
+
+
+
+"""
+
+from machineconfig.utils.path_extended import PathExtended
+from machineconfig.utils.options import choose_from_options
+from rich.console import Console
+from rich.panel import Panel
+
+
+console = Console()
+
+
+def main() -> None:
+    private_keys = [PathExtended(x).with_name(x.stem) for x in PathExtended.home().joinpath(".ssh").glob("*.pub")]
+    key_status = f"Found {len(private_keys)} key(s)" if private_keys else "No keys found"
+    console.print(Panel(f"🔑 SSH Identity Management\n🔍 {key_status} in ~/.ssh", title="[bold blue]Setup[/bold blue]", expand=False))
+
+    choice = choose_from_options(msg="Path to private key to be used when ssh'ing: ", options=[str(x) for x in private_keys] + ["I have the path to the key file", "I want to paste the key itself"], multi=False)
+
+    if choice == "I have the path to the key file":
+        path_to_key = PathExtended(input("📋 Enter path to private key: ")).expanduser().absolute()
+    elif choice == "I want to paste the key itself":
+        key_filename = input("📝 File name (default: my_pasted_key): ") or "my_pasted_key"
+        path_to_key = PathExtended.home().joinpath(f".ssh/{key_filename}")
+        path_to_key.parent.mkdir(parents=True, exist_ok=True)
+        path_to_key.write_text(input("🔑 Paste the private key: "), encoding="utf-8")
+    else:
+        path_to_key = PathExtended(choice)
+
+    txt = f"IdentityFile {path_to_key.collapseuser().as_posix()}"
+    config_path = PathExtended.home().joinpath(".ssh/config")
+
+    if config_path.exists():
+        current = config_path.read_text(encoding="utf-8")
+        config_action = "updated"
+    else:
+        current = txt
+        config_action = "created"
+    lines = current.split("\n")
+    found = False
+    for i, line in enumerate(lines):
+        if txt in line:
+            lines[i] = txt
+            found = True
+    if not found:
+        lines.insert(0, txt)
+    config_path.write_text("\n".join(lines), encoding="utf-8")
+
+    console.print(Panel(f"✅ Identity: {path_to_key.name}\n📄 Config {config_action}: {config_path}", title="[bold green]Complete[/bold green]", expand=False, border_style="green"))
+    return None
+
+
+if __name__ == "__main__":
+    pass