machineconfig 6.82__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"]

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] = [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}")
 
 
@@ -89,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

machineconfig-7.98.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: machineconfig
+Version: 7.98
+Summary: Dotfiles management package
+Author-email: Alex Al-Saffar <programmer@usa.com>
+License: Apache 2.0
+Project-URL: Homepage, https://github.com/thisismygitrepo/machineconfig
+Project-URL: Bug Tracker, https://github.com/thisismygitrepo/machineconfig/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: cryptography>=44.0.2
+Requires-Dist: fire>=0.7.0
+Requires-Dist: joblib>=1.5.2
+Requires-Dist: paramiko>=3.5.1
+Requires-Dist: randomname>=0.2.1
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rich>=14.0.0
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: gitpython>=3.1.44
+Requires-Dist: rclone-python>=0.1.23
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: typer-slim>=0.19.2
+Requires-Dist: typer>=0.19.2
+Provides-Extra: windows
+Requires-Dist: pywin32; extra == "windows"
+Provides-Extra: plot
+Requires-Dist: sqlalchemy>=2.0.43; extra == "plot"
+Requires-Dist: ipykernel>=6.30.1; extra == "plot"
+Requires-Dist: ipython>=9.5.0; extra == "plot"
+Requires-Dist: jupyterlab>=4.4.9; extra == "plot"
+Requires-Dist: kaleido>=1.1.0; extra == "plot"
+Requires-Dist: matplotlib>=3.10.6; extra == "plot"
+Requires-Dist: nbformat>=5.10.4; extra == "plot"
+Requires-Dist: numpy>=2.3.3; extra == "plot"
+Requires-Dist: plotly>=6.3.0; extra == "plot"
+Requires-Dist: polars>=1.33.1; extra == "plot"
+Requires-Dist: python-magic>=0.4.27; extra == "plot"
+
+
+<p align="center">
+
+<a href="https://github.com/thisismygitrepo/machineconfig/commits">
+<img src="https://img.shields.io/github/commit-activity/m/thisismygitrepo/machineconfig" />
+</a>
+
+</p>
+
+
+# 🧠 Welcome to **Machineconfig**
+
+**Machineconfig** is a cli-based cross-platform **Stack Manager** — It is a swiss-army knife; a *Package Manager*, *Configuration Manager*, *Automation Tool*, *Dotfiles Manager*, *Data Solution*, and *Code Manager*, among other functionalities covered, all rolled into one seamless experience, that is consistent across different platforms.
+
+
+## 💡 Motivation
+Your stack is awesome, but you need stack a manager for it, to put it together and maintain it.
+What is your stack? Say you have a new computer/ VM, how to set it?
+* A bunch of CLI tools.
+* [Optional] A bunch of softwares (GUIs for desktop environment)
+* [Public] A bunch of configuration files for your tools.
+* [Private] A bunch of secrets, passowords, tokens, credentials etc, etc.
+* Data (Both highly sensitive and encrypted less serious unencrypted data)
+* Code (your repositories).
+
+Wouldn't be nice if you can set it all up in 2 minutes? This is a hackable tool to get it done.
+
+Consider this concrete scenario: When setting up a new machine, VM, or Docker container, you often face dependency chains like this:
+
+```mermaid
+flowchart TD
+    A["Need to setup my [dev] environment"] --> B["need my tool x, e.g.: yadm"]
+    B --> C["Requires git"]
+    C --> D["Requires package manager, e.g. brew"]
+    D --> E["Requires curl"]
+    E --> F["Requires network setup / system update"]
+    F --> G["Requires system configuration access"]
+    G --> H["Finally ready to start setup the tool x."]
+```
+
+Machineconfig builds on shoulder of giants. A suite of best-in-class stack of projects on github are used, the most starred, active and written in Rust tools are used when possible. The goal is to provide a seamless experience that abstracts away the complexity of setting up and maintaining your digital environment. The goal of machineconfig is to replicate your setup, config, code, data and secrets on any machine, any os, in 5 minutes, using minimal user input. Then, from that point, machineconfig will help you maintain, update, backup and sync your digital life across all your devices, automatically.
+
+
+## ⚙️ Functional Overview
+
+| Category               | Comparable Tools                              | Description                                               |
+|------------------------|----------------------------------------------|-----------------------------------------------------------|
+| **Package Manager**     | `winget`, `apt`, `brew`, `nix`               | Installs and manages software packages across systems.    |
+| **Configuration Manager** | `Ansible`, `Chef`, `Puppet`                | Configures and maintains system‐level preferences.        |
+| **Automation Tool**     | `Airflow`, `Prefect`, `Dagster`, `Celery`    | Automates repetitive tasks, pipelines, orchestration.     |
+| **Dotfiles Manager**    | `chezmoi`, `yadm`, `rcm`, `GNU Stow`        | Synchronises dotfiles & personal configs across systems.  |
+| **Data Solution**       | `rclone`, `rsync`                            | Handles backups, mirroring and secure file sync.          |
+| **Code Manager**        | `strong‐box`, `Vault`                        | Manages and protects code snippets, secrets and creds.    |
+
+---
+
+
+# Install On Windows:
+
+```powershell
+# install tool the tool only:
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"  # Skip if UV is already installed
+uv tool install --upgrade --python 3.14 machineconfig
+# interactive install of machineconfig and following on to run it and make basic machine configuration (RECOMMENDED):
+iex (iwr bit.ly/cfgwindows).Content  # Or, if UV is installed: iex (uvx machineconfig define)
+# Quick install and configure (optionals are accepted by default):
+iex (iwr bit.ly/cfgwq).Content
+```
+
+
+# Install On Linux and MacOS
+
+```bash
+# install the tool only:
+curl -LsSf https://astral.sh/uv/install.sh | sh  # Skip if UV is already installed
+uv tool install --upgrade --python 3.14 machineconfig
+# interactive install of machineconfig and following on to run it and make basic machine configuration (RECOMMENDED):
+. <(curl -L bit.ly/cfglinux) # Or, if UV is installed: . <(uvx machineconfig define)
+```
+
+
+# Author
+Alex Al-Saffar. [email](mailto:programmer@usa.com)
+
+# Contributor
+Ruby Chan. [email](mailto:ruby.chan@sa.gov.au)
+
+
+[![Alex's github activity graph](https://github-readme-activity-graph.vercel.app/graph?username=thisismygitrepo)](https://github.com/ashutosh00710/github-readme-activity-graph)
+