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

machineconfig/scripts/python/helpers/helpers_devops/mount_helpers/device_entry.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DeviceEntry:
+	platform_name: str
+	key: str
+	device_path: str
+	device_type: str | None
+	label: str | None
+	mount_point: str | None
+	fs_type: str | None
+	size: str | None
+	extra: str | None
+	disk_number: int | None
+	partition_number: int | None
+	drive_letter: str | None

machineconfig/scripts/python/helpers/helpers_devops/mount_helpers/devices.py

@@ -0,0 +1,17 @@
+import platform
+
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.device_entry import DeviceEntry
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.linux import list_linux_devices
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.macos import list_macos_devices
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.windows import list_windows_devices
+
+
+def list_devices() -> list[DeviceEntry]:
+	platform_name = platform.system()
+	if platform_name == "Linux":
+		return list_linux_devices()
+	if platform_name == "Darwin":
+		return list_macos_devices()
+	if platform_name == "Windows":
+		return list_windows_devices()
+	return []

machineconfig/scripts/python/helpers/helpers_devops/mount_helpers/linux.py

@@ -0,0 +1,103 @@
+import json
+import os
+from pathlib import Path
+
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.commands import ensure_ok, run_command, run_command_sudo
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.device_entry import DeviceEntry
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.selection import pick_device
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.utils import as_str
+
+
+def _flatten_lsblk_devices(devices: list[dict[str, object]]) -> list[dict[str, object]]:
+	result: list[dict[str, object]] = []
+	stack = list(devices)
+	while stack:
+		item = stack.pop(0)
+		result.append(item)
+		children = item.get("children")
+		if isinstance(children, list):
+			for child in children:
+				if isinstance(child, dict):
+					stack.append(child)
+	return result
+
+
+def list_linux_devices() -> list[DeviceEntry]:
+	result = run_command(["lsblk", "-J", "-o", "NAME,SIZE,TYPE,FSTYPE,LABEL,MOUNTPOINT,UUID,MODEL"])
+	text = ensure_ok(result, "lsblk")
+	data = json.loads(text)
+	raw_devices = data.get("blockdevices")
+	entries: list[DeviceEntry] = []
+	if isinstance(raw_devices, list):
+		for item in _flatten_lsblk_devices(raw_devices):
+			name_value = item.get("name")
+			if not isinstance(name_value, str):
+				continue
+			device_type = item.get("type")
+			if not isinstance(device_type, str):
+				continue
+			if device_type not in {"disk", "part"}:
+				continue
+			device_path = f"/dev/{name_value}"
+			label = as_str(item.get("label"))
+			mount_point = as_str(item.get("mountpoint"))
+			fs_type = as_str(item.get("fstype"))
+			size = as_str(item.get("size"))
+			model = as_str(item.get("model"))
+			entries.append(
+				DeviceEntry(
+					platform_name="Linux",
+					key=name_value,
+					device_path=device_path,
+					device_type=device_type,
+					label=label,
+					mount_point=mount_point,
+					fs_type=fs_type,
+					size=size,
+					extra=model,
+					disk_number=None,
+					partition_number=None,
+					drive_letter=None,
+				)
+			)
+	return entries
+
+
+def mount_linux(entry: DeviceEntry, mount_point: str) -> None:
+	mount_path = Path(mount_point)
+	try:
+		mount_path.mkdir(parents=True, exist_ok=True)
+	except PermissionError:
+		mkdir_result = run_command_sudo(["mkdir", "-p", str(mount_path)])
+		ensure_ok(mkdir_result, "mkdir")
+	if os.geteuid() == 0:
+		result = run_command(["mount", entry.device_path, str(mount_path)])
+	else:
+		result = run_command_sudo(["mount", entry.device_path, str(mount_path)])
+	ensure_ok(result, "mount")
+
+
+def _is_partition_of_disk(partition: DeviceEntry, disk: DeviceEntry) -> bool:
+	if partition.device_type != "part" or disk.device_type != "disk":
+		return False
+	if partition.key == disk.key:
+		return False
+	if not partition.key.startswith(disk.key):
+		return False
+	return True
+
+
+def select_linux_partition(entries: list[DeviceEntry], entry: DeviceEntry) -> DeviceEntry:
+	if entry.device_type != "disk":
+		return entry
+	candidates = [device for device in entries if _is_partition_of_disk(device, entry)]
+	with_fs = [device for device in candidates if device.fs_type is not None and device.fs_type != ""]
+	if len(with_fs) == 1:
+		return with_fs[0]
+	if len(with_fs) > 1:
+		return pick_device(with_fs, header="Select partition to mount")
+	if len(candidates) == 1:
+		return candidates[0]
+	if len(candidates) > 1:
+		return pick_device(candidates, header="Select partition to mount")
+	raise RuntimeError("No mountable partitions found for selected disk")

machineconfig/scripts/python/helpers/helpers_devops/mount_helpers/macos.py

@@ -0,0 +1,100 @@
+import plistlib
+from pathlib import Path
+
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.commands import ensure_ok, run_command
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.device_entry import DeviceEntry
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.utils import as_str, format_size_bytes
+
+
+def _diskutil_info(identifier: str) -> dict[str, object]:
+	result = run_command(["diskutil", "info", "-plist", identifier])
+	text = ensure_ok(result, "diskutil info")
+	return plistlib.loads(text.encode("utf-8"))
+
+
+def list_macos_devices() -> list[DeviceEntry]:
+	result = run_command(["diskutil", "list", "-plist"])
+	text = ensure_ok(result, "diskutil list")
+	data = plistlib.loads(text.encode("utf-8"))
+	entries: list[DeviceEntry] = []
+	all_disks = data.get("AllDisksAndPartitions")
+	if isinstance(all_disks, list):
+		for disk in all_disks:
+			if not isinstance(disk, dict):
+				continue
+			partitions = disk.get("Partitions")
+			if isinstance(partitions, list) and partitions:
+				for partition in partitions:
+					if not isinstance(partition, dict):
+						continue
+					identifier = partition.get("DeviceIdentifier")
+					if not isinstance(identifier, str):
+						continue
+					info = _diskutil_info(identifier)
+					mount_point = as_str(info.get("MountPoint"))
+					label = as_str(info.get("VolumeName"))
+					fs_type = as_str(info.get("FilesystemType"))
+					if fs_type is None:
+						fs_type = as_str(info.get("FileSystemType"))
+					size_value = info.get("TotalSize")
+					size = format_size_bytes(size_value) if isinstance(size_value, int) else None
+					media_name = as_str(info.get("MediaName"))
+					device_path = f"/dev/{identifier}"
+					entries.append(
+						DeviceEntry(
+							platform_name="Darwin",
+							key=identifier,
+							device_path=device_path,
+							device_type="part",
+							label=label,
+							mount_point=mount_point,
+							fs_type=fs_type,
+							size=size,
+							extra=media_name,
+							disk_number=None,
+							partition_number=None,
+							drive_letter=None,
+						)
+					)
+			else:
+				identifier = disk.get("DeviceIdentifier")
+				if not isinstance(identifier, str):
+					continue
+				info = _diskutil_info(identifier)
+				mount_point = as_str(info.get("MountPoint"))
+				label = as_str(info.get("VolumeName"))
+				fs_type = as_str(info.get("FilesystemType"))
+				if fs_type is None:
+					fs_type = as_str(info.get("FileSystemType"))
+				size_value = info.get("TotalSize")
+				size = format_size_bytes(size_value) if isinstance(size_value, int) else None
+				media_name = as_str(info.get("MediaName"))
+				device_path = f"/dev/{identifier}"
+				entries.append(
+					DeviceEntry(
+						platform_name="Darwin",
+						key=identifier,
+						device_path=device_path,
+						device_type="disk",
+						label=label,
+						mount_point=mount_point,
+						fs_type=fs_type,
+						size=size,
+						extra=media_name,
+						disk_number=None,
+						partition_number=None,
+						drive_letter=None,
+					)
+				)
+	return entries
+
+
+def mount_macos(entry: DeviceEntry, mount_point: str) -> None:
+	if mount_point == "-":
+		result = run_command(["diskutil", "mount", entry.key])
+		ensure_ok(result, "diskutil mount")
+		return
+	mount_path = Path(mount_point)
+	mount_path.mkdir(parents=True, exist_ok=True)
+	result = run_command(["diskutil", "mount", "-mountPoint", str(mount_path), entry.key])
+	ensure_ok(result, "diskutil mount")

machineconfig/scripts/python/helpers/helpers_devops/mount_helpers/selection.py

@@ -0,0 +1,47 @@
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.device_entry import DeviceEntry
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.utils import format_device
+
+
+def pick_device(entries: list[DeviceEntry], header: str) -> DeviceEntry:
+	from machineconfig.utils.options import choose_from_options
+
+	options: list[str] = []
+	map_option: dict[str, DeviceEntry] = {}
+	for idx, entry in enumerate(entries):
+		option = f"{idx:02d} {format_device(entry)}"
+		options.append(option)
+		map_option[option] = entry
+	choice = choose_from_options(options=options, msg="Select a device", multi=False, header=header, tv=True)
+	selected = map_option.get(choice)
+	if selected is None:
+		raise RuntimeError("Selection not found")
+	return selected
+
+
+def resolve_device(entries: list[DeviceEntry], query: str) -> DeviceEntry:
+	query_value = query.strip()
+	if query_value in {"?", ""}:
+		return pick_device(entries, header="Available devices")
+	exact_matches = [
+		entry
+		for entry in entries
+		if entry.device_path.lower() == query_value.lower()
+		or entry.key.lower() == query_value.lower()
+		or (entry.label is not None and entry.label.lower() == query_value.lower())
+	]
+	if len(exact_matches) == 1:
+		return exact_matches[0]
+	if len(exact_matches) > 1:
+		return pick_device(exact_matches, header="Multiple matches")
+	partial_matches = [
+		entry
+		for entry in entries
+		if query_value.lower() in entry.device_path.lower()
+		or query_value.lower() in entry.key.lower()
+		or (entry.label is not None and query_value.lower() in entry.label.lower())
+	]
+	if len(partial_matches) == 1:
+		return partial_matches[0]
+	if len(partial_matches) > 1:
+		return pick_device(partial_matches, header="Multiple matches")
+	return pick_device(entries, header="Available devices")

machineconfig/scripts/python/helpers/helpers_devops/mount_helpers/utils.py

@@ -0,0 +1,28 @@
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.device_entry import DeviceEntry
+
+
+def as_str(value: object) -> str | None:
+	if isinstance(value, str) and value != "":
+		return value
+	return None
+
+
+def format_size_bytes(size_bytes: int) -> str:
+	units = ["B", "KB", "MB", "GB", "TB", "PB"]
+	value = float(size_bytes)
+	unit_index = 0
+	while value >= 1024 and unit_index < len(units) - 1:
+		value = value / 1024
+		unit_index += 1
+	if unit_index == 0:
+		return f"{int(value)} {units[unit_index]}"
+	return f"{value:.1f} {units[unit_index]}"
+
+
+def format_device(entry: DeviceEntry) -> str:
+	label = entry.label if entry.label is not None and entry.label != "" else "-"
+	fs_type = entry.fs_type if entry.fs_type is not None and entry.fs_type != "" else "-"
+	size = entry.size if entry.size is not None and entry.size != "" else "-"
+	mount_point = entry.mount_point if entry.mount_point is not None and entry.mount_point != "" else "-"
+	extra = entry.extra if entry.extra is not None and entry.extra != "" else "-"
+	return f"{entry.key} | {entry.device_path} | {fs_type} | {size} | {mount_point} | {label} | {extra}"

machineconfig/scripts/python/helpers/helpers_devops/mount_helpers/windows.py

@@ -0,0 +1,91 @@
+import json
+import re
+
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.commands import ensure_ok, run_powershell
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.device_entry import DeviceEntry
+from machineconfig.scripts.python.helpers.helpers_devops.mount_helpers.utils import as_str, format_size_bytes
+
+
+def _normalize_ps_json(raw_text: str) -> list[dict[str, object]]:
+	if raw_text.strip() == "":
+		return []
+	data = json.loads(raw_text)
+	if isinstance(data, list):
+		return [x for x in data if isinstance(x, dict)]
+	if isinstance(data, dict):
+		return [data]
+	return []
+
+
+def list_windows_devices() -> list[DeviceEntry]:
+	partitions_result = run_powershell(
+		"Get-Partition | Select-Object DiskNumber,PartitionNumber,DriveLetter,Size,Type,Guid | ConvertTo-Json"
+	)
+	volumes_result = run_powershell(
+		"Get-Volume | Select-Object DriveLetter,FileSystemLabel,FileSystem,Size,SizeRemaining,DriveType,Path | ConvertTo-Json"
+	)
+	partitions_text = ensure_ok(partitions_result, "Get-Partition")
+	volumes_text = ensure_ok(volumes_result, "Get-Volume")
+	partitions = _normalize_ps_json(partitions_text)
+	volumes = _normalize_ps_json(volumes_text)
+	volume_map: dict[str, dict[str, object]] = {}
+	for volume in volumes:
+		drive_letter = as_str(volume.get("DriveLetter"))
+		if isinstance(drive_letter, str):
+			volume_map[drive_letter.upper()] = volume
+	entries: list[DeviceEntry] = []
+	for partition in partitions:
+		disk_number = partition.get("DiskNumber")
+		partition_number = partition.get("PartitionNumber")
+		drive_letter = as_str(partition.get("DriveLetter"))
+		volume = volume_map.get(drive_letter.upper()) if isinstance(drive_letter, str) else None
+		label = None
+		fs_type = None
+		mount_point = None
+		extra = as_str(partition.get("Type"))
+		if isinstance(volume, dict):
+			label = as_str(volume.get("FileSystemLabel"))
+			fs_type = as_str(volume.get("FileSystem"))
+			mount_point = as_str(volume.get("Path"))
+			if mount_point is None and isinstance(drive_letter, str) and drive_letter != "":
+				mount_point = f"{drive_letter}:\\"
+		size_value = partition.get("Size")
+		size = format_size_bytes(size_value) if isinstance(size_value, int) else None
+		key = f"Disk {disk_number} Part {partition_number}"
+		device_path = as_str(partition.get("Guid")) or key
+		entries.append(
+			DeviceEntry(
+				platform_name="Windows",
+				key=key,
+				device_path=device_path,
+				device_type="part",
+				label=label,
+				mount_point=mount_point,
+				fs_type=fs_type,
+				size=size,
+				extra=extra,
+				disk_number=disk_number if isinstance(disk_number, int) else None,
+				partition_number=partition_number if isinstance(partition_number, int) else None,
+				drive_letter=drive_letter.upper() if isinstance(drive_letter, str) and drive_letter != "" else None,
+			)
+		)
+	return entries
+
+
+def _normalize_drive_letter(value: str) -> str:
+	match = re.search(r"([A-Za-z])", value)
+	if match is None:
+		raise RuntimeError("Invalid drive letter")
+	return match.group(1).upper()
+
+
+def mount_windows(entry: DeviceEntry, mount_point: str) -> None:
+	if entry.disk_number is None or entry.partition_number is None:
+		raise RuntimeError("Partition details not available")
+	letter = _normalize_drive_letter(mount_point)
+	command = (
+		f"Get-Partition -DiskNumber {entry.disk_number} -PartitionNumber {entry.partition_number} | "
+		f"Set-Partition -NewDriveLetter {letter}"
+	)
+	result = run_powershell(command)
+	ensure_ok(result, "Set-Partition")

machineconfig/scripts/python/helpers/helpers_devops/run_script.py

@@ -0,0 +1,197 @@
+
+
+"""run python/shell scripts from pre-defined directorys, or, run command/file in the machineconfig environment
+
+Recursively Searched Predefined Directories:
+
+
+* 'private' : $HOME/dotfiles/scripts
+
+* 'public'  : $HOME/.config/machineconfig/scripts
+
+* 'library' : $MACHINECONFIG_LIBRARY_ROOT/jobs/scripts
+
+* 'dynamic' : fetched from GitHub repository on the fly (relies on latest commit, rather than the version currently installed)
+
+* 'custom'  : custom directories from comma separated entry 'scripts' under 'general' section @ ~/dotfiles/machineconfig/defaults.ini
+
+"""
+
+
+import typer
+from typing import Annotated, Optional, Literal
+
+
+def run_py_script(ctx: typer.Context,
+                  name: Annotated[str, typer.Argument(help="Name of script to run, e.g., 'a' for a.py, or command to execute")] = "",
+                  where: Annotated[Literal["all", "a", "private", "p", "public", "b", "library", "l", "dynamic", "d", "custom", "c"], typer.Option("--where", "-w", help="Where to look for the script")] = "all",
+                  interactive: Annotated[bool, typer.Option(..., "--interactive", "-i", help="Interactive selection of scripts to run")] = False,
+                  command: Annotated[Optional[bool], typer.Option(..., "--command", "-c", help="Run as command")] = False,
+                  list_scripts: Annotated[bool, typer.Option(..., "--list", "-l", help="List available scripts in all locations")] = False,
+                ) -> None:
+    if command:
+        exec(name)
+        return
+
+    from pathlib import Path
+    if list_scripts:
+        from machineconfig.scripts.python.helpers.helpers_search.script_help import list_available_scripts
+        list_available_scripts(where=where)
+        return
+
+    if not interactive and not name:
+        typer.echo("❌ ERROR: You must provide a script name or use --interactive option to select a script.")
+        raise typer.Exit(code=1)
+    target_file: Optional[Path] = None
+
+    if where in ["dynamic", "d"]:
+        # src/machineconfig/jobs/scripts/python_scripts/a.py
+        if "." in name: resolved_names: list[str] = [name]
+        else: resolved_names = [f"{name}{a_suffix}" for a_suffix in [".py", ".sh", "", ".ps1", ".bat", ".cmd"]]
+        urls = [f"""https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/jobs/scripts_dynamic/{a_resolved_name}""" for a_resolved_name in resolved_names]
+        for a_url in urls:
+            try:
+                print(f"Fetching temporary script from {a_url} ...")
+                import requests
+                response = requests.get(a_url)
+                if response.status_code != 200:
+                    print(f"❌ ERROR: Could not fetch script '{name}.py' from repository. Status Code: {response.status_code}")
+                    raise RuntimeError(f"Could not fetch script '{name}.py' from repository.")
+                script_content = response.text
+                target_file = Path.home().joinpath("tmp_results", "tmp_scripts", "python", f"{name}.py")
+                target_file.parent.mkdir(parents=True, exist_ok=True)
+                target_file.write_text(script_content, encoding="utf-8")
+            except Exception as _e:
+                pass
+
+
+    if target_file is None and Path(name).is_file():
+        if name.endswith(".py"):
+            import machineconfig
+            import subprocess
+            import sys
+            subprocess.run([sys.executable, name], cwd=machineconfig.__path__[0])
+            return
+        else:
+            if Path(name).suffix in [".sh", ".ps1", ".bat", ".cmd", ""]:
+                target_file = Path(name)
+            else:
+                print(f"❌ Error: File '{name}' is not a recognized script type. Supported types are {'.py', '.sh', '.ps1', '.bat', '.cmd', ''}.")
+                raise typer.Exit(code=1)
+
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT, LIBRARY_ROOT, DEFAULTS_PATH
+    private_root = Path.home().joinpath("dotfiles/scripts")  # local directory
+    public_root = CONFIG_ROOT.joinpath("scripts")  # local machineconfig directory
+    library_root = LIBRARY_ROOT.joinpath("jobs", "scripts")
+
+    def get_custom_roots() -> list[Path]:
+        custom_roots: list[Path] = []
+        if DEFAULTS_PATH.is_file():
+            from configparser import ConfigParser
+            config = ConfigParser()
+            config.read(DEFAULTS_PATH)
+            if config.has_section("general") and config.has_option("general", "scripts"):
+                custom_dirs = config.get("general", "scripts").split(",")
+                for custom_dir in custom_dirs:
+                    custom_path = Path(custom_dir.strip()).expanduser().resolve()
+                    if custom_path.is_dir():
+                        custom_roots.append(custom_path)
+        return custom_roots
+
+    roots: list[Path] = []
+    match where:
+        case "all" | "a":
+            roots = [private_root, public_root, library_root] + get_custom_roots()
+        case "private" | "p":
+            roots = [private_root]
+        case "public" | "b":
+            roots = [public_root]
+        case "library" | "l":
+            roots = [library_root]
+        case "dynamic" | "d":
+            roots = []
+        case "custom" | "c":
+            roots = get_custom_roots()
+
+    suffixes: list[str]
+    if "." in name:
+        suffixes = [""]
+    else:
+        import platform
+        if platform.system() == "Windows":
+            suffixes = [".py", ".bat", ".cmd", ".ps1"]
+        elif platform.system() == "Darwin" or platform.system() == "Linux":
+            suffixes = [""]  # files without suffix could be shell scripts, and that already cover files with .sh suffix without duplications
+        else:
+            suffixes = [".py"]
+
+    # Finding target file
+    potential_matches: list[Path] = []
+    if target_file is None:
+        for a_root in roots:
+            for a_suffix in suffixes:
+                if a_root.joinpath(f"{name}{a_suffix}").is_file():
+                    target_file = a_root.joinpath(f"{name}{a_suffix}")
+                    break  # perfect match
+                potential_matches += [a_file for a_file in a_root.rglob(f"*{name}*{a_suffix}") if a_file.is_file()]
+
+    if target_file is None:
+        if len(potential_matches) == 1:
+            target_file = potential_matches[0]
+        elif len(potential_matches) == 0:
+            typer.echo(ctx.get_help())
+            typer.echo()
+            typer.echo(typer.style(f"❌ ERROR: Could not find script '{name}'.", fg=typer.colors.RED, bold=True))
+            typer.echo("Searched in:")
+            for r in roots:
+                typer.echo(f"  - {r}")
+            raise typer.Exit(code=1)
+        else:
+            typer.echo(typer.style(f"Warning: Could not find script '{name}'. Checked {len(potential_matches)} candidate files, trying interactively:", fg=typer.colors.YELLOW))
+            from machineconfig.utils.options import choose_from_options
+            options = [str(p) for p in potential_matches]
+            chosen_file_part = choose_from_options(options, multi=False, msg="Select the script to run:", tv=True, preview="bat")
+            target_file = Path(chosen_file_part)
+
+    typer.echo(typer.style(f"✅ Found script at: {target_file}", fg=typer.colors.GREEN))
+    if target_file.suffix == ".py":
+        from machineconfig.utils.code import get_uv_command_executing_python_file, exit_then_run_shell_script
+        shell_script = get_uv_command_executing_python_file(python_file=str(target_file), uv_project_dir=None, uv_with=None, prepend_print=False)
+        exit_then_run_shell_script(script=shell_script)
+    else:
+        from machineconfig.utils.code import exit_then_run_shell_file
+        exit_then_run_shell_file(script_path=str(target_file), strict=True)
+
+
+def copy_script_to_local(ctx: typer.Context,
+                         name: Annotated[str, typer.Argument(help="Name of the temporary python script to copy, e.g., 'a' for a.py")],
+                         alias: Annotated[Optional[str], typer.Option("--alias", "-a", help="Whether to create call it a different name locally")] = None
+                         ) -> None:
+    """
+    Copy a temporary python script stored in machineconfig/scripts/python/helpers/tmp_py_scripts to the local machine.
+    """
+    url = f"""https://raw.githubusercontent.com/thisismygitrepo/machineconfig/refs/heads/main/src/machineconfig/scripts/python/helpers/tmp_py_scripts/{name}.py"""
+    import requests
+    response = requests.get(url)
+    if response.status_code != 200:
+        typer.echo(ctx.get_help())
+        typer.echo()
+        typer.echo(typer.style(f"❌ ERROR: Could not fetch script '{name}.py' from repository. Status Code: {response.status_code}", fg=typer.colors.RED, bold=True))
+        raise typer.Exit(code=1)
+    script_content = response.text
+    from machineconfig.utils.source_of_truth import CONFIG_ROOT
+    local_path = CONFIG_ROOT.joinpath(f"scripts_python/{alias or name}.py")
+    with open(local_path, "w") as f:
+        f.write(script_content)
+    typer.echo(typer.style(f"✅ Script '{name}.py' has been copied to '{local_path}'.", fg=typer.colors.GREEN))
+
+
+def get_app():
+    app = typer.Typer(
+        name="run-tmp-script",
+        help="Helper to run temporary python scripts stored in machineconfig/scripts/python/helpers/tmp_py_scripts",
+        no_args_is_help=True,
+    )
+    from machineconfig.jobs.scripts_dynamic import a
+    app.command()(a.main)
+    return app

machineconfig/scripts/python/helpers/helpers_devops/themes/choose_starship_theme.ps1

@@ -0,0 +1,41 @@
+$presets = @{
+    "nerd-font-symbols" = "Changes the symbols for each module to use Nerd Font symbols."
+    "no-nerd-font" = "Changes the symbols so that no Nerd Font symbols are used."
+    "bracketed-segments" = "Changes the format to show segments in brackets."
+    "plain-text-symbols" = "Changes the symbols for each module into plain text."
+    "no-runtime-versions" = "Hides the version of language runtimes."
+    "no-empty-icons" = "Does not show icons if the toolset is not found."
+    "pure-preset" = "Emulates the look and behavior of Pure."
+    "pastel-powerline" = "Inspired by M365Princess."
+    "tokyo-night" = "Inspired by tokyo-night-vscode-theme."
+    "gruvbox-rainbow" = "Inspired by Pastel Powerline and Tokyo Night."
+    "jetpack" = "Pseudo minimalist preset inspired by geometry and spaceship."
+}
+
+$input_list = $presets.Keys | ForEach-Object { "$_`t$($presets[$_])" }
+
+$preview_config = "$env:TEMP/starship_preview.toml"
+
+# Preview command for PowerShell
+# We need to split the line and get the first part.
+# tv replaces {} with the line.
+# We use powershell -c for the preview command to be safe and consistent.
+
+$preview_cmd = "powershell -c `"`$preset = '{}'.Split('`t')[0]; starship preset `$preset > $preview_config; `$env:STARSHIP_CONFIG='$preview_config'; `$env:STARSHIP_SHELL='powershell'; starship prompt`""
+
+if (Get-Command "tv" -ErrorAction SilentlyContinue) {
+    $selected_line = $input_list | tv --preview-command $preview_cmd --preview-size 50
+} elseif (Get-Command "fzf" -ErrorAction SilentlyContinue) {
+    # fzf fallback
+    $selected_line = $input_list | fzf --ansi --delimiter "`t" --with-nth 1,2 --preview "powershell -c `"`$preset = {1}; starship preset `$preset > $preview_config; `$env:STARSHIP_CONFIG='$preview_config'; `$env:STARSHIP_SHELL='powershell'; starship prompt`"" --preview-window bottom:50%
+} else {
+    Write-Host "Error: 'tv' or 'fzf' not found."
+    exit 1
+}
+
+if ($selected_line) {
+    $selected_preset = $selected_line.Split("`t")[0]
+    Write-Host "Applying $selected_preset..."
+    starship preset $selected_preset -o "$HOME/.config/starship.toml"
+    Write-Host "Done!"
+}