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

machineconfig/utils/ssh_utils/wsl.py

@@ -0,0 +1,210 @@
+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 _infer_windows_home_from_permissions() -> 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
+    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:
+        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() -> Path:
+    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()
+
+
+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) -> None:
+    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
+        link_path.unlink()
+    elif link_path.exists():
+        raise FileExistsError(link_path)
+    link_path.symlink_to(target_path, target_is_directory=True)
+
+
+def copy_when_inside_wsl(source: Path | str, target: Path | str, overwrite: bool) -> 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() / 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() -> 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
+        target_path = _resolve_wsl_home_on_windows()
+        link_path = Path.home() / "wsl"
+        _ensure_symlink(link_path, target_path)
+        return
+    target_path = _resolve_windows_home_from_wsl()
+    link_path = Path.home() / "win"
+    _ensure_symlink(link_path, target_path)
+
+
+if __name__ == "__main__":
+    copy_when_inside_wsl(Path("projects/source.txt"), Path("windows_projects/source.txt"), True)
+    copy_when_inside_windows(Path("documents/example.txt"), Path("linux_documents/example.txt"), True)

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"]
@@ -35,7 +36,8 @@ class Response:
     def __call__(self, *args: Any, **kwargs: Any) -> Optional[str]:
         _ = args, kwargs
         return self.op.rstrip() if type(self.op) is str else None
-
+    def __repr__(self) -> str:
+        return f"Response({self.input=}, {self.output=}, {self.desc=}, {self.op=}, {self.ip=}, {self.err=}, {self.returncode=})"
     @property
     def op(self) -> str:
         return self.output.stdout
@@ -97,115 +99,3 @@ class Response:
         txt = tmp1 + Text(str(self.input), style="white") + tmp2 + Text("\n".join(list_str), style="white")
         con.print(Panel(txt, title=f"🖥️  {self.desc}", subtitle=f"📋 {desc}", width=150, style="bold cyan on black"))
         return self
-
-
-'''
-class Terminal:
-    def __init__(self, stdout: Optional[int] = subprocess.PIPE, stderr: Optional[int] = subprocess.PIPE, stdin: Optional[int] = subprocess.PIPE, elevated: bool = False):
-        self.machine: str = platform.system()
-        self.elevated: bool = elevated
-        self.stdout = stdout
-        self.stderr = stderr
-        self.stdin = stdin
-
-    # def set_std_system(self): self.stdout = sys.stdout; self.stderr = sys.stderr; self.stdin = sys.stdin
-    # def set_std_pipe(self):
-    #     self.stdout = subprocess.PIPE
-    #     self.stderr = subprocess.PIPE
-    #     self.stdin = subprocess.PIPE
-
-    # def set_std_null(self):
-    #     self.stdout, self.stderr, self.stdin = subprocess.DEVNULL, subprocess.DEVNULL, subprocess.DEVNULL  # Equivalent to `echo 'foo' &> /dev/null`
-
-    def run(self, *cmds: str, shell: Optional[SHELLS] = "default", check: bool = False, ip: Optional[str] = None) -> Response:  # Runs SYSTEM commands like subprocess.run
-        """Blocking operation. Thus, if you start a shell via this method, it will run in the main and won't stop until you exit manually IF stdin is set to sys.stdin, otherwise it will run and close quickly. Other combinations of stdin, stdout can lead to funny behaviour like no output but accept input or opposite.
-        * This method is short for: res = subprocess.run("powershell command", capture_output=True, shell=True, text=True) and unlike os.system(cmd), subprocess.run(cmd) gives much more control over the output and input.
-        * `shell=True` loads up the profile of the shell called so more specific commands can be run. Importantly, on Windows, the `start` command becomes availalbe and new windows can be launched.
-        * `capture_output` prevents the stdout to redirect to the stdout of the script automatically, instead it will be stored in the Response object returned. # `capture_output=True` same as `stdout=subprocess.PIPE, stderr=subprocess.PIPE`"""
-        my_list = list(
-            cmds
-        )  # `subprocess.Popen` (process open) is the most general command. Used here to create asynchronous job. `subprocess.run` is a thin wrapper around Popen that makes it wait until it finishes the task. `suprocess.call` is an archaic command for pre-Python-3.5.
-        if self.machine == "Windows" and shell in {"powershell", "pwsh"}:
-            my_list = [shell, "-Command"] + my_list  # alternatively, one can run "cmd"
-        if self.elevated is False or self.is_user_admin():
-            resp: subprocess.CompletedProcess[str] = subprocess.run(my_list, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=check, input=ip)
-        else:
-            resp = __import__("ctypes").windll.shell32.ShellExecuteW(None, "runas", sys.executable, " ".join(sys.argv), None, 1)
-    return Response.from_completed_process(resp)
-    @staticmethod
-    def is_user_admin() -> bool:  # adopted from: https://stackoverflow.com/questions/19672352/how-to-run-script-with-elevated-privilege-on-windows"""
-        if os.name == "nt":
-            try:
-                return __import__("ctypes").windll.shell32.IsUserAnAdmin()
-            except Exception:
-                import traceback
-
-                traceback.print_exc()
-                print("Admin check failed, assuming not an admin.")
-                return False
-        else:
-            return os.getuid() == 0  # Check for root on Posix
-'''
-
-    # def run_shell_script(self, script: str, shell: SHELLS = "default", verbose: bool = False):
-    #     if self.machine == "Linux":
-    #         script = "#!/bin/bash" + "\n" + script  # `source` is only available in bash.
-    #     script_file = PathExtended.tmpfile(name="tmp_shell_script", suffix=".ps1" if self.machine == "Windows" else ".sh", folder="tmp_scripts")
-    #     script_file.write_text(script, newline={"Windows": None, "Linux": "\n"}[self.machine])
-    #     if shell == "default":
-    #         if self.machine == "Windows":
-    #             start_cmd = "powershell"  # default shell on Windows is cmd which is not very useful. (./source is not available)
-    #             full_command: Union[list[str], str] = [start_cmd, str(script_file)]  # shell=True will cause this to be a string anyway (with space separation)
-    #         else:
-    #             start_cmd = "bash"
-    #             full_command = f"{start_cmd} {script_file}"  # full_command = [start_cmd, str(script_file)]
-    #     else:
-    #         full_command = f"{shell} {script_file}"  # full_command = [shell, str(tmp_file)]
-    #     if verbose:
-    #         desc = "Script to be executed:"
-    #         if platform.system() == "Windows":
-    #             lexer = "powershell"
-    #         elif platform.system() == "Linux":
-    #             lexer = "sh"
-    #         elif platform.system() == "Darwin":
-    #             lexer = "sh"  # macOS uses similar shell to Linux
-    #         else:
-    #             raise NotImplementedError(f"Platform {platform.system()} not supported.")
-    #         from rich.console import Console
-    #         from rich.panel import Panel
-    #         from rich.syntax import Syntax
-    #         import rich.progress as pb
-
-    #         console = Console()
-    #         console.print(Panel(Syntax(code=script, lexer=lexer), title=f"📄 {desc}"), style="bold red")
-    #         with pb.Progress(transient=True) as progress:
-    #             _task = progress.add_task(f"Running Script @ {script_file}", total=None)
-    #             resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
-    #     else:
-    #         resp = subprocess.run(full_command, stderr=self.stderr, stdin=self.stdin, stdout=self.stdout, text=True, shell=True, check=False)
-    #     return Response.from_completed_process(resp)
-
-#     def run_py(self, script: str, wdir: OPLike = None, interactive: bool = True, ipython: bool = True, shell: Optional[str] = None, terminal: str = "", new_window: bool = True, header: bool = True):  # async run, since sync run is meaningless.
-#         script = (Terminal.get_header(wdir=wdir, toolbox=True) if header else "") + script + ("\nDisplayData.set_pandas_auto_width()\n" if terminal in {"wt", "powershell", "pwsh"} else "")
-#         py_script = PathExtended.tmpfile(name="tmp_python_script", suffix=".py", folder="tmp_scripts/terminal")
-#         py_script.write_text(f"""print(r'''{script}''')""" + "\n" + script)
-#         print(f"""🚀 [ASYNC PYTHON SCRIPT] Script URI:
-#    {py_script.absolute().as_uri()}""")
-#         print("Script to be executed asyncronously: ", py_script.absolute().as_uri())
-#         shell_script = f"""
-# {f"cd {wdir}" if wdir is not None else ""}
-# {"ipython" if ipython else "python"} {"-i" if interactive else ""} {py_script}
-# """
-#         shell_path = PathExtended.tmpfile(name="tmp_shell_script", suffix=".sh" if self.machine == "Linux" else ".ps1", folder="tmp_scripts/shell")
-#         shell_path.write_text(shell_script)
-#         if shell is None and self.machine == "Windows":
-#             shell = "pwsh"
-#         window = "start" if new_window and self.machine == "Windows" else ""
-#         os.system(f"{window} {terminal} {shell} {shell_script}")
-
-    #     @staticmethod
-    #     def run_as_admin(file: PLike, params: Any, wait: bool = False):
-    #         proce_info = install_n_import(library="win32com", package="pywin32", fromlist=["shell.shell.ShellExecuteEx"]).shell.shell.ShellExecuteEx(lpVerb='runas', lpFile=file, lpParameters=params)
-    #         # TODO update PATH for this to take effect immediately.
-    #         if wait: time.sleep(1)
-    #         return proce_info

machineconfig/utils/tst.py

@@ -0,0 +1,20 @@
+from typing import Callable, ParamSpec, TypeVar, Any, Dict
+
+P = ParamSpec('P')
+R = TypeVar('R')
+
+def typed_function(func: Callable[P, R], signature_dict: Dict[str, Any]) -> Callable[P, R]:
+    """
+    Returns the function with its signature preserved using ParamSpec.
+
+    The signature_dict is passed for potential future use or documentation,
+    but is not currently used in the implementation.
+
+    Args:
+        func: The function whose signature is to be preserved.
+        signature_dict: A dictionary describing the function's signature (not used).
+
+    Returns:
+        The original function, typed with ParamSpec to preserve its signature.
+    """
+    return func

machineconfig/utils/upgrade_packages.py

@@ -1,5 +1,15 @@
+
 """
+
 Generate uv add commands from pyproject.toml dependency groups.
+
+#!/bin/bash
+# rm ./pyproject.toml
+rm ./uv.lock
+rm -rfd .venv
+uv venv --python 3.13
+uv init
+
 """
 
 from pathlib import Path
@@ -15,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] = [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}")
+                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]
                 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}")
 
 
@@ -79,13 +93,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