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

machineconfig/utils/ssh_utils/wsl.py

@@ -0,0 +1,147 @@
+import platform
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from machineconfig.utils.ssh_utils.wsl_helper import (
+    ensure_relative_path,
+    remove_path,
+    ensure_wsl_environment,
+    ensure_windows_environment,
+    ensure_linux_environment,
+    resolve_windows_home_from_wsl,
+    resolve_wsl_home_on_windows,
+    run_windows_copy_command,
+    ensure_symlink,
+    normalize_port_spec_for_firewall,
+)
+
+
+def copy_when_inside_wsl(source: Path | str, target: Path | str, overwrite: bool, windows_username: str | None) -> None:
+    ensure_wsl_environment()
+    source_relative = ensure_relative_path(source)
+    target_relative = ensure_relative_path(target)
+    source_path = Path.home() / source_relative
+    target_path = resolve_windows_home_from_wsl(windows_username) / target_relative
+    if not source_path.exists():
+        raise FileNotFoundError(source_path)
+    if target_path.exists():
+        if not overwrite:
+            raise FileExistsError(target_path)
+        remove_path(target_path)
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    if source_path.is_dir():
+        shutil.copytree(source_path, target_path, dirs_exist_ok=False)
+        return
+    print(f"Copying {source_path} to {target_path}")
+    shutil.copy2(source_path, target_path)
+
+
+def copy_when_inside_windows(source: Path | str, target: Path | str, overwrite: bool) -> None:
+    ensure_windows_environment()
+    source_relative = ensure_relative_path(source)
+    target_relative = ensure_relative_path(target)
+    source_path = Path.home() / source_relative
+    target_path = resolve_wsl_home_on_windows() / target_relative
+    if not source_path.exists():
+        raise FileNotFoundError(source_path)
+    if target_path.exists():
+        if not overwrite:
+            raise FileExistsError(target_path)
+        remove_path(target_path)
+    run_windows_copy_command(source_path, target_path)
+
+
+def link_wsl_and_windows(windows_username: str | None) -> None:
+    system = platform.system()
+    if system == "Darwin":
+        raise RuntimeError("link_wsl_and_windows is not designed for macOS")
+    try:
+        ensure_wsl_environment()
+    except RuntimeError:
+        try:
+            ensure_windows_environment()
+        except RuntimeError as exc:
+            raise RuntimeError("link_wsl_and_windows must run inside Windows or WSL") from exc
+        print("🔗 Running inside Windows, linking to WSL home...")
+        target_path = resolve_wsl_home_on_windows()
+        link_path = Path.home() / "wsl"
+        created = ensure_symlink(link_path, target_path)
+        if created:
+            print(f"✅ Created symlink: {link_path} -> {target_path}")
+        else:
+            print(f"✅ Symlink already exists: {link_path} -> {target_path}")
+        return
+    print("🔗 Running inside WSL, linking to Windows home...")
+    target_path = resolve_windows_home_from_wsl(windows_username)
+    link_path = Path.home() / "win"
+    created = ensure_symlink(link_path, target_path)
+    if created:
+        print(f"✅ Created symlink: {link_path} -> {target_path}")
+    else:
+        print(f"✅ Symlink already exists: {link_path} -> {target_path}")
+
+
+def open_wsl_port(ports_spec: str) -> None:
+    ensure_windows_environment()
+    normalized_ports, description = normalize_port_spec_for_firewall(ports_spec)
+    rule_name = f"WSL Ports {description}"
+    # Build PowerShell array syntax for -LocalPort parameter (e.g., @('3000-4000','8080'))
+    port_parts = normalized_ports.split(",")
+    ps_array = "@(" + ",".join(f"'{p}'" for p in port_parts) + ")"
+    script = f"New-NetFirewallRule -DisplayName '{rule_name}' -Direction Inbound -LocalPort {ps_array} -Protocol TCP -Action Allow"
+    print(f"🔥 Opening firewall for ports: {description}...")
+    result = subprocess.run(["powershell.exe", "-NoLogo", "-NoProfile", "-Command", script], capture_output=True, text=True)
+    if result.returncode == 0:
+        print(f"✅ Firewall rule created for ports: {description}")
+    else:
+        print(f"❌ Failed to create firewall rule: {result.stderr.strip()}")
+
+
+def change_ssh_port(port: int) -> None:
+    ensure_linux_environment()
+    if port < 1 or port > 65535:
+        raise ValueError(f"Invalid port number: {port}")
+
+    sshd_config = Path("/etc/ssh/sshd_config")
+    if not sshd_config.exists():
+        raise FileNotFoundError(f"SSH config file not found: {sshd_config}")
+
+    print(f"🔧 Changing SSH port to {port}...")
+
+    content = sshd_config.read_text()
+    new_content = re.sub(r"^#?\s*Port\s+\d+", f"Port {port}", content, flags=re.MULTILINE)
+    if f"Port {port}" not in new_content:
+        new_content = f"Port {port}\n" + new_content
+
+    print(f"📝 Updating {sshd_config}...")
+    result = subprocess.run(["sudo", "tee", str(sshd_config)], input=new_content.encode(), capture_output=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to update sshd_config: {result.stderr.decode()}")
+    print(f"✅ Updated {sshd_config}")
+
+    override_dir = Path("/etc/systemd/system/ssh.socket.d")
+    override_file = override_dir / "override.conf"
+    override_content = f"""[Socket]
+ListenStream=
+ListenStream={port}
+"""
+    print(f"📝 Creating systemd socket override at {override_file}...")
+    subprocess.run(["sudo", "mkdir", "-p", str(override_dir)], check=True)
+    result = subprocess.run(["sudo", "tee", str(override_file)], input=override_content.encode(), capture_output=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"Failed to create override file: {result.stderr.decode()}")
+    print("✅ Created systemd socket override")
+
+    print("🔄 Restarting SSH services...")
+    subprocess.run(["sudo", "systemctl", "daemon-reload"], check=True)
+    subprocess.run(["sudo", "systemctl", "restart", "ssh.socket"], check=False)
+    subprocess.run(["sudo", "service", "ssh", "restart"], check=False)
+    print(f"✅ SSH port changed to {port}")
+    print(f"⚠️  Remember to open port {port} in Windows Firewall if running in WSL")
+
+
+if __name__ == "__main__":
+    copy_when_inside_wsl(Path("projects/source.txt"), Path("windows_projects/source.txt"), overwrite=True, windows_username=None)
+    copy_when_inside_windows(Path("documents/example.txt"), Path("linux_documents/example.txt"), overwrite=True)

machineconfig/utils/ssh_utils/wsl_helper.py

@@ -0,0 +1,217 @@
+import os
+import platform
+import stat
+import shutil
+import subprocess
+from pathlib import Path, PureWindowsPath
+
+
+def ensure_relative_path(requested: Path | str) -> Path:
+    path = Path(requested)
+    if path.is_absolute():
+        raise ValueError("paths must be relative to the home directory")
+    if any(part == ".." for part in path.parts):
+        raise ValueError("paths must stay within the home directory")
+    return path
+
+
+def remove_path(path: Path) -> None:
+    if path.is_symlink() or path.is_file():
+        path.unlink()
+        return
+    shutil.rmtree(path)
+
+
+def ensure_wsl_environment() -> None:
+    if os.environ.get("WSL_DISTRO_NAME"):
+        return
+    if "microsoft" in platform.release().lower():
+        return
+    raise RuntimeError("copy_when_inside_wsl must run inside WSL")
+
+
+def ensure_windows_environment() -> None:
+    if os.name != "nt":
+        raise RuntimeError("copy_when_inside_windows must run inside Windows")
+    if os.environ.get("WSL_DISTRO_NAME"):
+        raise RuntimeError("copy_when_inside_windows must run inside Windows")
+
+
+def ensure_linux_environment() -> None:
+    if platform.system() != "Linux":
+        raise RuntimeError("change_ssh_port requires Linux environment")
+
+
+def infer_windows_home_from_permissions(windows_username: str | None) -> Path:
+    base_dir = Path("/mnt/c/Users")
+    try:
+        entries = list(base_dir.iterdir())
+    except FileNotFoundError as exc:
+        raise RuntimeError("unable to find /mnt/c/Users") from exc
+    if windows_username:
+        candidate = base_dir / windows_username
+        if candidate.is_dir():
+            return candidate
+        raise RuntimeError(f"specified Windows user directory not found: {candidate}")
+    candidates: list[Path] = []
+    for entry in entries:
+        if not entry.is_dir():
+            continue
+        if entry.name.lower() == "public" or entry.name.lower() == "all users":
+            continue
+        try:
+            mode = stat.S_IMODE(entry.stat().st_mode)
+        except OSError:
+            continue
+        if mode == 0o777:
+            candidates.append(entry)
+    if len(candidates) != 1:
+        wsl_user = os.environ.get("USER") or os.environ.get("LOGNAME")
+        if wsl_user:
+            for candidate in candidates:
+                if candidate.name == wsl_user:
+                    return candidate
+        non_default = [c for c in candidates if c.name.lower() not in ("default", "default user")]
+        if len(non_default) == 1:
+            return non_default[0]
+        options = ", ".join(sorted(candidate.name for candidate in candidates)) or "none"
+        raise RuntimeError(f"unable to infer Windows home directory (candidates: {options})")
+    return candidates[0]
+
+
+def resolve_windows_home_from_wsl(windows_username: str | None) -> Path:
+    if windows_username:
+        return infer_windows_home_from_permissions(windows_username)
+    user_profile = os.environ.get("USERPROFILE")
+    if user_profile:
+        windows_path = PureWindowsPath(user_profile)
+        drive = windows_path.drive
+        if drive:
+            drive_letter = drive.rstrip(":").lower()
+            tail = Path(*windows_path.parts[1:])
+            candidate = Path("/mnt") / drive_letter / tail
+            if candidate.exists():
+                return candidate
+    return infer_windows_home_from_permissions(windows_username)
+
+
+def decode_wsl_output(raw_bytes: bytes) -> str:
+    try:
+        return raw_bytes.decode("utf-16-le")
+    except UnicodeDecodeError:
+        return raw_bytes.decode()
+
+
+def get_single_wsl_distribution() -> str:
+    process = subprocess.run(["wsl.exe", "-l"], capture_output=True, text=False, check=True)
+    stdout = decode_wsl_output(process.stdout).replace("\ufeff", "")
+    distributions: list[str] = []
+    for raw_line in stdout.splitlines():
+        line = raw_line.strip()
+        if not line or line.lower().startswith("windows subsystem for linux"):
+            continue
+        normalized = line.lstrip("* ").replace("(Default)", "").strip()
+        if normalized:
+            distributions.append(normalized)
+    if len(distributions) != 1:
+        raise RuntimeError("unable to pick a single WSL distribution")
+    return distributions[0]
+
+
+def resolve_wsl_home_on_windows() -> Path:
+    distribution = get_single_wsl_distribution()
+    home_root = Path(rf"\\wsl$\{distribution}\home")
+    try:
+        entries = list(home_root.iterdir())
+    except FileNotFoundError as exc:
+        raise RuntimeError(f"unable to locate WSL home directories for {distribution}") from exc
+    except OSError as exc:
+        raise RuntimeError(f"unable to inspect WSL home directories for {distribution}") from exc
+    user_dirs = [entry for entry in entries if entry.is_dir()]
+    if len(user_dirs) != 1:
+        options = ", ".join(sorted(entry.name for entry in user_dirs)) or "none"
+        raise RuntimeError(f"unable to infer WSL user directory (candidates: {options})")
+    return user_dirs[0]
+
+
+def quote_for_powershell(path: Path) -> str:
+    return "'" + str(path).replace("'", "''") + "'"
+
+
+def run_windows_copy_command(source_path: Path, target_path: Path) -> None:
+    source_is_dir = source_path.is_dir()
+    parent_literal = quote_for_powershell(target_path.parent)
+    source_literal = quote_for_powershell(source_path)
+    target_literal = quote_for_powershell(target_path)
+    script = (
+        "$ErrorActionPreference = 'Stop'; "
+        f"New-Item -ItemType Directory -Path {parent_literal} -Force | Out-Null; "
+        f"Copy-Item -LiteralPath {source_literal} -Destination {target_literal}"
+        f"{' -Recurse' if source_is_dir else ''} -Force"
+    )
+    print(f"Copying {source_path} to {target_path}")
+    subprocess.run(["powershell.exe", "-NoLogo", "-NoProfile", "-Command", script], check=True)
+
+
+def ensure_symlink(link_path: Path, target_path: Path) -> bool:
+    if not target_path.exists():
+        raise FileNotFoundError(target_path)
+    if link_path.is_symlink():
+        existing_target = Path(os.path.realpath(link_path))
+        desired_target = Path(os.path.realpath(target_path))
+        if os.path.normcase(str(existing_target)) == os.path.normcase(str(desired_target)):
+            return False
+        link_path.unlink()
+    elif link_path.exists():
+        raise FileExistsError(link_path)
+    link_path.symlink_to(target_path, target_is_directory=True)
+    return True
+
+
+def parse_port_spec(port_spec: str) -> list[int]:
+    ports: list[int] = []
+    for part in port_spec.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            range_parts = part.split("-", maxsplit=1)
+            start = int(range_parts[0].strip())
+            end = int(range_parts[1].strip())
+            if start > end:
+                raise ValueError(f"Invalid port range: {part} (start > end)")
+            ports.extend(range(start, end + 1))
+        else:
+            ports.append(int(part))
+    return ports
+
+
+def normalize_port_spec_for_firewall(port_spec: str) -> tuple[str, str]:
+    """Validates and normalizes port spec for New-NetFirewallRule -LocalPort parameter.
+    Returns (normalized_spec, human_readable_description).
+    New-NetFirewallRule natively supports ranges (e.g. '5000-5020') and comma-separated values.
+    """
+    parts: list[str] = []
+    for raw_part in port_spec.split(","):
+        part = raw_part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            range_parts = part.split("-", maxsplit=1)
+            start = int(range_parts[0].strip())
+            end = int(range_parts[1].strip())
+            if start < 1 or start > 65535 or end < 1 or end > 65535:
+                raise ValueError(f"Port numbers must be between 1 and 65535: {part}")
+            if start > end:
+                raise ValueError(f"Invalid port range: {part} (start > end)")
+            parts.append(f"{start}-{end}")
+        else:
+            port = int(part)
+            if port < 1 or port > 65535:
+                raise ValueError(f"Invalid port number: {port}")
+            parts.append(str(port))
+    if not parts:
+        raise ValueError("No valid ports provided")
+    normalized = ",".join(parts)
+    description = normalized.replace(",", ", ")
+    return normalized, description

machineconfig/utils/terminal.py

@@ -4,6 +4,7 @@ from typing import Any, BinaryIO, Optional, Union
 from typing import Literal, TypeAlias
 from dataclasses import dataclass
 
+
 SHELLS: TypeAlias = Literal["default", "cmd", "powershell", "pwsh", "bash"]  # pwsh.exe is PowerShell (community) and powershell.exe is Windows Powershell (msft)
 CONSOLE: TypeAlias = Literal["wt", "cmd"]
 MACHINE: TypeAlias = Literal["Windows", "Linux", "Darwin"]

machineconfig/utils/upgrade_packages.py

@@ -25,44 +25,48 @@ def generate_uv_add_commands(pyproject_path: Path, output_path: Path) -> None:
         pyproject_path: Path to the pyproject.toml file
         output_path: Path where to write the uv add commands
     """
-    # Read pyproject.toml
     with open(pyproject_path, "rb") as f:
         pyproject_data: dict[str, Any] = tomllib.load(f)
 
     commands: list[str] = []
 
-    # Handle main dependencies (no group)
     if "project" in pyproject_data and "dependencies" in pyproject_data["project"]:
-        main_deps = pyproject_data["project"]["dependencies"]
+        main_deps: list[str] = pyproject_data["project"]["dependencies"]
         if main_deps:
-            # Extract package names without version constraints
-            package_names = [extract_package_name(dep) for dep in main_deps]
-            commands.append(f"uv add {' '.join(package_names)}")
+            package_names: list[str] = [f"'{extract_package_name(dep)}'" for dep in main_deps]
+            commands.append(f"uv add --no-cache {' '.join(package_names)}")
 
-    # Handle optional dependencies as groups
     if "project" in pyproject_data and "optional-dependencies" in pyproject_data["project"]:
-        optional_deps = pyproject_data["project"]["optional-dependencies"]
+        optional_deps: dict[str, list[str]] = pyproject_data["project"]["optional-dependencies"]
         for group_name, deps in optional_deps.items():
             if deps:
-                package_names = [extract_package_name(dep) for dep in deps]
-                commands.append(f"uv add {' '.join(package_names)} --group {group_name}")
+                package_names = [f"'{extract_package_name(dep)}'" for dep in deps]
+                commands.append(f"uv add --no-cache --group {group_name} {' '.join(package_names)}")
 
-    # Handle dependency-groups (like dev)
     if "dependency-groups" in pyproject_data:
-        dep_groups = pyproject_data["dependency-groups"]
+        dep_groups: dict[str, list[str]] = pyproject_data["dependency-groups"]
         for group_name, deps in dep_groups.items():
             if deps:
-                package_names = [extract_package_name(dep) for dep in deps]
+                package_names = [f"'{extract_package_name(dep)}'" for dep in deps]
                 if group_name == "dev":
-                    commands.append(f"uv add {' '.join(package_names)} --dev")
+                    commands.append(f"uv add --no-cache --dev {' '.join(package_names)}")
                 else:
-                    commands.append(f"uv add {' '.join(package_names)} --group {group_name}")
-
-    # Write commands to output file
-    with open(output_path, "w") as f:
-        for command in commands:
-            f.write(command + "\n")
-
+                    commands.append(f"uv add --no-cache --group {group_name} {' '.join(package_names)}")
+
+    # with open(output_path, "w") as f:
+    #     f.write("#!/bin/bash\n")
+    #     f.write("set -e\n\n")
+    #     f.write("uv cache clean --force\n\n")
+    #     for command in commands:
+    #         f.write(command + "\n")
+    script = f"""
+#!/bin/bash
+set -e
+uv cache clean --force
+rm -rfd .venv
+{"".join(f"{command}\n" for command in commands)}
+"""
+    output_path.write_text(script.strip() + "\n", encoding="utf-8")
     print(f"Generated {len(commands)} uv add commands in {output_path}")
 
 
@@ -74,12 +78,8 @@ def extract_package_name(dependency_spec: str) -> str:
         "rich>=14.0.0" -> "rich"
         "requests>=2.32.5" -> "requests"
         "pywin32" -> "pywin32"
-        "package[extra]>=1.0" -> "package"
+        "package[extra]>=1.0" -> "package[extra]"
     """
-    # Handle extras like "package[extra]>=1.0" first
-    if "[" in dependency_spec:
-        dependency_spec = dependency_spec.split("[")[0].strip()
-
     # Split on common version operators and take the first part
     for operator in [">=", "<=", "==", "!=", ">", "<", "~=", "===", "@"]:
         if operator in dependency_spec:
@@ -89,13 +89,85 @@ def extract_package_name(dependency_spec: str) -> str:
     return dependency_spec.strip()
 
 
+def upgrade_machine_config_version() -> None:
+    """
+    Upgrade machineconfig version in pyproject.toml and all source files.
+    
+    Reads current version from pyproject.toml, bumps it by 0.01, and replaces
+    all occurrences of machineconfig>={old_version} and machineconfig[group]>={old_version}
+    with the new version in Python (.py), shell (.sh), and PowerShell (.ps1) files.
+    """
+    current_dir: Path = Path.cwd()
+    pyproject_file: Path = current_dir / "pyproject.toml"
+    
+    # Read current version from pyproject.toml
+    with open(pyproject_file, "rb") as f:
+        pyproject_data: dict[str, Any] = tomllib.load(f)
+    
+    current_version_str: str = pyproject_data["project"]["version"]
+    version_parts: list[str] = current_version_str.split(".")
+    major: int = int(version_parts[0])
+    minor: int = int(version_parts[1])
+    
+    # Bump minor version by 1, preserving zero-padding
+    new_minor: int = minor + 1
+    # Preserve the same number of digits as the original minor version
+    minor_width: int = len(version_parts[1])
+    new_version: str = f"{major}.{new_minor:0{minor_width}d}"
+    
+    # Collect all optional dependency groups
+    optional_groups: set[str] = set()
+    if "project" in pyproject_data and "optional-dependencies" in pyproject_data["project"]:
+        optional_groups.update(pyproject_data["project"]["optional-dependencies"].keys())
+    if "dependency-groups" in pyproject_data:
+        optional_groups.update(pyproject_data["dependency-groups"].keys())
+    
+    print(f"Upgrading from {current_version_str} to {new_version}")
+    print(f"Found optional groups: {', '.join(sorted(optional_groups))}")
+    
+    # Update pyproject.toml
+    content: str = pyproject_file.read_text(encoding="utf-8")
+    updated_content: str = content.replace(f'version = "{current_version_str}"', f'version = "{new_version}"')
+    pyproject_file.write_text(updated_content, encoding="utf-8")
+    print(f"Updated pyproject.toml: {current_version_str} -> {new_version}")
+    
+    # Find all Python files and replace version constraints
+    py_files: list[Path] = list(current_dir.glob("**/*.py")) + list(current_dir.glob("**/*.sh")) + list(current_dir.glob("**/*.ps1"))
+    
+    # Also include Dockerfile files
+    dockerfile_files: list[Path] = [f for f in current_dir.glob("**/Dockerfile*") if f.is_file()]
+    py_files.extend(dockerfile_files)
+    
+    files_updated: int = 0
+    for file_path in py_files:
+        try:
+            file_content: str = file_path.read_text(encoding="utf-8")
+            updated_file_content: str = file_content
+            
+            # Replace base constraint (without group)
+            old_constraint: str = f"machineconfig>={current_version_str}"
+            new_constraint: str = f"machineconfig>={new_version}"
+            if old_constraint in updated_file_content:
+                updated_file_content = updated_file_content.replace(old_constraint, new_constraint)
+            
+            # Replace constraints with optional groups
+            for group in optional_groups:
+                old_group_constraint: str = f"machineconfig[{group}]>={current_version_str}"
+                new_group_constraint: str = f"machineconfig[{group}]>={new_version}"
+                if old_group_constraint in updated_file_content:
+                    updated_file_content = updated_file_content.replace(old_group_constraint, new_group_constraint)
+            
+            if updated_file_content != file_content:
+                file_path.write_text(updated_file_content, encoding="utf-8")
+                files_updated += 1
+                print(f"Updated {file_path.relative_to(current_dir)}")
+        except (UnicodeDecodeError, PermissionError):
+            # Skip files that can't be read as text
+            pass
+    print(f"Updated {files_updated} files with version constraint")
+    from machineconfig.utils.code import exit_then_run_shell_script
+    exit_then_run_shell_script(f"cd {current_dir}; uv sync")
+
+
 if __name__ == "__main__":
-    # Example usage
-    current_dir = Path.cwd()
-    pyproject_file = current_dir / "pyproject.toml"
-    output_file = current_dir / "uv_add_commands.txt"
-
-    if pyproject_file.exists():
-        generate_uv_add_commands(pyproject_file, output_file)
-    else:
-        print(f"pyproject.toml not found at {pyproject_file}")
+    upgrade_machine_config_version()

machineconfig/utils/ve.py

@@ -1,18 +1,20 @@
-from machineconfig.utils.io import read_ini
-import platform
+
 from typing import Optional
-from pathlib import Path
 
 
-def get_ve_path_and_ipython_profile(init_path: Path) -> tuple[Optional[str], Optional[str]]:
+def get_ve_path_and_ipython_profile(init_path: "Path") -> tuple[Optional[str], Optional[str]]:
     """Works with .ve.ini .venv and .ve_path"""
     ve_path: Optional[str] = None
     ipy_profile: Optional[str] = None
     tmp = init_path
+
+    from machineconfig.utils.io import read_ini
+
     for _ in init_path.parents:
         if tmp.joinpath(".ve.ini").exists():
             ini = read_ini(tmp.joinpath(".ve.ini"))
             if ve_path is None:
+                
                 try:
                     ve_path = ini["specs"]["ve_path"]
                 except KeyError:
@@ -39,6 +41,8 @@ def get_ve_path_and_ipython_profile(init_path: Path) -> tuple[Optional[str], Opt
 
 
 def get_ve_activate_line(ve_root: str):
+    import platform
+    from pathlib import Path
     if platform.system() == "Windows":
         q = Path(ve_root).expanduser().relative_to(Path.home()).as_posix()
         activate_ve_line = f". $HOME/{q}/Scripts/activate.ps1"
@@ -47,3 +51,7 @@ def get_ve_activate_line(ve_root: str):
     else:
         raise NotImplementedError(f"Platform {platform.system()} not supported.")
     return activate_ve_line
+
+
+if __name__ == "__main__":
+    from pathlib import Path