isozap 0.1.0__tar.gz

isozap-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shariar Imtiaz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

isozap-0.1.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: isozap
+Version: 0.1.0
+Summary: A safe cross-platform command-line utility for creating bootable USB drives from ISO images.
+Author: Shariar Imtiaz
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/simtiaz019/IsoZap
+Project-URL: Issues, https://github.com/simtiaz019/IsoZap/issues
+Keywords: iso,usb,bootable-usb,usb-flasher,iso-flasher,windows,macos,linux,cli,bootable,disk,flash
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# IsoZap
+
+Create bootable USB drives safely from your terminal.
+
+IsoZap is a cross-platform command-line utility for creating bootable USB drives from ISO images on Windows, macOS, and Linux.
+
+> **WARNING:** IsoZap writes directly to storage devices. Selecting the wrong disk may permanently destroy data. IsoZap includes safeguards designed to prevent accidental system-disk selection, but users remain responsible for confirming the correct destination device.
+
+## Overview
+
+IsoZap discovers conservative removable/external whole-disk targets, validates the source and capacity, displays a destructive-operation summary, and requires explicit confirmation before writing. It supports raw hybrid images and specially prepared FAT32 Windows installer media.
+
+## Features
+
+- Native device discovery for Windows, macOS, and Linux
+- System-, boot-, internal-, and partition-target rejection
+- Device identity and capacity revalidation immediately before writing
+- Exact `ERASE` confirmation or an intentionally verbose automation flag
+- Non-destructive `--dry-run`
+- Source SHA-256 checking and optional raw-write read-back verification
+- Windows x64 and ARM64 UEFI loader validation
+- FAT32-compatible splitting of Windows `install.wim` files larger than 4 GiB
+- Standard-library-only runtime
+
+## Supported operating systems
+
+| Host | Raw/hybrid images | Prepared Windows installer media |
+|---|---:|---:|
+| Windows | Yes | Yes, UEFI-focused |
+| macOS | Yes | Yes, UEFI-focused |
+| Linux | Yes | Yes, UEFI-focused |
+
+Python 3.9 or newer is required. ChromeOS, Android, iOS, and restricted Python environments generally do not expose raw USB disks and are not supported.
+
+## Supported ISO types and limitations
+
+- Linux/Unix hybrid ISOs and raw `.img` files are written byte-for-byte.
+- Arbitrary non-hybrid ISOs are not made bootable merely by writing them.
+- Windows installer mode creates MBR + FAT32 media and validates the selected x64 or ARM64 UEFI loader.
+- Windows installer mode does not guarantee legacy BIOS/CSM booting or support every customized ISO.
+- Windows host support and creating media from a Windows ISO are separate capabilities.
+- Platform logic and package builds are tested with mocks; release 0.1.0 has not yet completed broad physical-device testing.
+
+## Installation
+
+Recommended:
+
+```bash
+pipx install isozap
+```
+
+Alternative:
+
+```bash
+python -m pip install isozap
+```
+
+Do not install IsoZap with `sudo pip` or an Administrator-level pip. Install as your normal user; elevate only the later flashing command when required.
+
+## Usage
+
+```text
+isozap --help
+isozap --version
+python -m isozap --help
+```
+
+The existing direct command style is retained:
+
+```bash
+isozap IMAGE --type {hybrid,raw,windows}
+```
+
+## Device listing
+
+```bash
+isozap --list
+```
+
+Only whole disks considered removable or external and not identified as system/boot disks are displayed.
+
+## Flashing an ISO
+
+macOS or Linux:
+
+```bash
+sudo "$(command -v isozap)" ~/Downloads/ubuntu.iso --type hybrid
+sudo "$(command -v isozap)" ~/Downloads/windows.iso --type windows --arch x64
+```
+
+Windows Administrator PowerShell:
+
+```powershell
+isozap C:\Users\me\Downloads\ubuntu.iso --type hybrid
+isozap C:\Users\me\Downloads\windows.iso --type windows --arch x64
+```
+
+Verify a publisher-provided source checksum and read back a raw write:
+
+```bash
+sudo "$(command -v isozap)" image.iso --type hybrid --sha256 EXPECTED_SHA256 --verify-write
+```
+
+For automation, `--device` still requires a currently safe discovered disk and `--yes-i-really-mean-it` explicitly replaces the prompt:
+
+```bash
+sudo "$(command -v isozap)" image.img --type raw --device /dev/sdX --yes-i-really-mean-it
+```
+
+Never guess a device identifier.
+
+## Dry-run
+
+```bash
+isozap image.iso --type hybrid --device /dev/sdX --dry-run
+```
+
+Dry-run performs source, target, identity, and capacity checks and displays the intended operation. It does not mount, unmount, repartition, format, write, or eject any device. Windows installer structural mounting is deferred until an actual operation.
+
+## Safety protections
+
+IsoZap rejects partitions, internal/non-removable targets, known system or boot disks, insufficient capacity, targets that disappear, and targets whose size/name/hardware identity changes between selection and execution. Windows explicitly maps the running system drive; macOS protects startup and reported APFS physical stores; Linux follows the block-device tree containing `/`, `/boot`, or `/boot/efi`.
+
+No automated safeguard can replace checking the displayed identifier, model, and size.
+
+## Administrator/root requirements
+
+Listing and dry-run do not require application installation as an administrator. Actual raw-device access does. Windows users should open an Administrator terminal. macOS/Linux users should install normally, then use `sudo` only when launching the destructive flash operation.
+
+## Windows notes
+
+IsoZap uses structured `Get-Disk`/`Get-Partition` PowerShell data and `\\.\PhysicalDriveN`; drive letters are never treated as physical disks. Raw writes take the selected disk offline during access and restore it afterward. Windows installer mode uses diskpart because repartitioning is necessary for MBR + FAT32 media. Windows' built-in formatter limits FAT32 to 32 GiB, so larger USB drives receive a 32 GiB installer partition and leave the remaining space unallocated.
+
+## macOS notes
+
+IsoZap uses plist output from `diskutil`, rejects internal disks and the startup disk/known APFS backing stores, unmounts the selected whole disk, and writes through `/dev/rdiskN` for raw-image performance.
+
+## Linux notes
+
+IsoZap uses JSON `lsblk` data and protects the top-level disk containing `/`, `/boot`, or `/boot/efi`, including nested LVM/device-mapper layouts represented in the block tree. Windows media additionally needs `parted`, `dosfstools`, and mount tools.
+
+## Development
+
+macOS/Linux:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e ".[dev]"
+```
+
+Windows PowerShell:
+
+```powershell
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install -e ".[dev]"
+```
+
+## Testing
+
+```bash
+python -m pytest
+isozap --help
+isozap --version
+python -m isozap --help
+```
+
+Tests mock destructive and system-level operations. Never point a test at a real disk.
+
+## Building
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Platform changes require mocked safety tests.
+
+## Security
+
+See [SECURITY.md](SECURITY.md) for private reporting guidance and security scope.
+
+## License
+
+IsoZap is available under the MIT License. See [LICENSE](LICENSE).
+
+## Disclaimer
+
+IsoZap is provided without warranty. Successful writing does not guarantee that an image supports USB booting or that the target firmware supports the image. Back up important data and test only with a disposable USB drive until you are confident in your platform and image combination.

isozap-0.1.0/README.md

@@ -0,0 +1,192 @@
+# IsoZap
+
+Create bootable USB drives safely from your terminal.
+
+IsoZap is a cross-platform command-line utility for creating bootable USB drives from ISO images on Windows, macOS, and Linux.
+
+> **WARNING:** IsoZap writes directly to storage devices. Selecting the wrong disk may permanently destroy data. IsoZap includes safeguards designed to prevent accidental system-disk selection, but users remain responsible for confirming the correct destination device.
+
+## Overview
+
+IsoZap discovers conservative removable/external whole-disk targets, validates the source and capacity, displays a destructive-operation summary, and requires explicit confirmation before writing. It supports raw hybrid images and specially prepared FAT32 Windows installer media.
+
+## Features
+
+- Native device discovery for Windows, macOS, and Linux
+- System-, boot-, internal-, and partition-target rejection
+- Device identity and capacity revalidation immediately before writing
+- Exact `ERASE` confirmation or an intentionally verbose automation flag
+- Non-destructive `--dry-run`
+- Source SHA-256 checking and optional raw-write read-back verification
+- Windows x64 and ARM64 UEFI loader validation
+- FAT32-compatible splitting of Windows `install.wim` files larger than 4 GiB
+- Standard-library-only runtime
+
+## Supported operating systems
+
+| Host | Raw/hybrid images | Prepared Windows installer media |
+|---|---:|---:|
+| Windows | Yes | Yes, UEFI-focused |
+| macOS | Yes | Yes, UEFI-focused |
+| Linux | Yes | Yes, UEFI-focused |
+
+Python 3.9 or newer is required. ChromeOS, Android, iOS, and restricted Python environments generally do not expose raw USB disks and are not supported.
+
+## Supported ISO types and limitations
+
+- Linux/Unix hybrid ISOs and raw `.img` files are written byte-for-byte.
+- Arbitrary non-hybrid ISOs are not made bootable merely by writing them.
+- Windows installer mode creates MBR + FAT32 media and validates the selected x64 or ARM64 UEFI loader.
+- Windows installer mode does not guarantee legacy BIOS/CSM booting or support every customized ISO.
+- Windows host support and creating media from a Windows ISO are separate capabilities.
+- Platform logic and package builds are tested with mocks; release 0.1.0 has not yet completed broad physical-device testing.
+
+## Installation
+
+Recommended:
+
+```bash
+pipx install isozap
+```
+
+Alternative:
+
+```bash
+python -m pip install isozap
+```
+
+Do not install IsoZap with `sudo pip` or an Administrator-level pip. Install as your normal user; elevate only the later flashing command when required.
+
+## Usage
+
+```text
+isozap --help
+isozap --version
+python -m isozap --help
+```
+
+The existing direct command style is retained:
+
+```bash
+isozap IMAGE --type {hybrid,raw,windows}
+```
+
+## Device listing
+
+```bash
+isozap --list
+```
+
+Only whole disks considered removable or external and not identified as system/boot disks are displayed.
+
+## Flashing an ISO
+
+macOS or Linux:
+
+```bash
+sudo "$(command -v isozap)" ~/Downloads/ubuntu.iso --type hybrid
+sudo "$(command -v isozap)" ~/Downloads/windows.iso --type windows --arch x64
+```
+
+Windows Administrator PowerShell:
+
+```powershell
+isozap C:\Users\me\Downloads\ubuntu.iso --type hybrid
+isozap C:\Users\me\Downloads\windows.iso --type windows --arch x64
+```
+
+Verify a publisher-provided source checksum and read back a raw write:
+
+```bash
+sudo "$(command -v isozap)" image.iso --type hybrid --sha256 EXPECTED_SHA256 --verify-write
+```
+
+For automation, `--device` still requires a currently safe discovered disk and `--yes-i-really-mean-it` explicitly replaces the prompt:
+
+```bash
+sudo "$(command -v isozap)" image.img --type raw --device /dev/sdX --yes-i-really-mean-it
+```
+
+Never guess a device identifier.
+
+## Dry-run
+
+```bash
+isozap image.iso --type hybrid --device /dev/sdX --dry-run
+```
+
+Dry-run performs source, target, identity, and capacity checks and displays the intended operation. It does not mount, unmount, repartition, format, write, or eject any device. Windows installer structural mounting is deferred until an actual operation.
+
+## Safety protections
+
+IsoZap rejects partitions, internal/non-removable targets, known system or boot disks, insufficient capacity, targets that disappear, and targets whose size/name/hardware identity changes between selection and execution. Windows explicitly maps the running system drive; macOS protects startup and reported APFS physical stores; Linux follows the block-device tree containing `/`, `/boot`, or `/boot/efi`.
+
+No automated safeguard can replace checking the displayed identifier, model, and size.
+
+## Administrator/root requirements
+
+Listing and dry-run do not require application installation as an administrator. Actual raw-device access does. Windows users should open an Administrator terminal. macOS/Linux users should install normally, then use `sudo` only when launching the destructive flash operation.
+
+## Windows notes
+
+IsoZap uses structured `Get-Disk`/`Get-Partition` PowerShell data and `\\.\PhysicalDriveN`; drive letters are never treated as physical disks. Raw writes take the selected disk offline during access and restore it afterward. Windows installer mode uses diskpart because repartitioning is necessary for MBR + FAT32 media. Windows' built-in formatter limits FAT32 to 32 GiB, so larger USB drives receive a 32 GiB installer partition and leave the remaining space unallocated.
+
+## macOS notes
+
+IsoZap uses plist output from `diskutil`, rejects internal disks and the startup disk/known APFS backing stores, unmounts the selected whole disk, and writes through `/dev/rdiskN` for raw-image performance.
+
+## Linux notes
+
+IsoZap uses JSON `lsblk` data and protects the top-level disk containing `/`, `/boot`, or `/boot/efi`, including nested LVM/device-mapper layouts represented in the block tree. Windows media additionally needs `parted`, `dosfstools`, and mount tools.
+
+## Development
+
+macOS/Linux:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e ".[dev]"
+```
+
+Windows PowerShell:
+
+```powershell
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install -e ".[dev]"
+```
+
+## Testing
+
+```bash
+python -m pytest
+isozap --help
+isozap --version
+python -m isozap --help
+```
+
+Tests mock destructive and system-level operations. Never point a test at a real disk.
+
+## Building
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Platform changes require mocked safety tests.
+
+## Security
+
+See [SECURITY.md](SECURITY.md) for private reporting guidance and security scope.
+
+## License
+
+IsoZap is available under the MIT License. See [LICENSE](LICENSE).
+
+## Disclaimer
+
+IsoZap is provided without warranty. Successful writing does not guarantee that an image supports USB booting or that the target firmware supports the image. Back up important data and test only with a disposable USB drive until you are confident in your platform and image combination.

isozap-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "isozap"
+version = "0.1.0"
+description = "A safe cross-platform command-line utility for creating bootable USB drives from ISO images."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Shariar Imtiaz" }]
+keywords = ["iso", "usb", "bootable-usb", "usb-flasher", "iso-flasher", "windows", "macos", "linux", "cli", "bootable", "disk", "flash"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: System :: Installation/Setup",
+  "Topic :: System :: Systems Administration",
+]
+
+[project.scripts]
+isozap = "isozap.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/simtiaz019/IsoZap"
+Issues = "https://github.com/simtiaz019/IsoZap/issues"
+
+[project.optional-dependencies]
+dev = ["build>=1.2", "pytest>=8", "twine>=5"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+addopts = "-q"
+testpaths = ["tests"]

isozap-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

isozap-0.1.0/src/isozap/__init__.py

@@ -0,0 +1,8 @@
+"""IsoZap: create bootable USB media safely."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("isozap")
+except PackageNotFoundError:  # source tree without an installed distribution
+    __version__ = "0+unknown"

isozap-0.1.0/src/isozap/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

isozap-0.1.0/src/isozap/cli.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__
+from .devices import safe_disks
+from .flash import raw_write, sha256
+from .models import Disk
+from .safety import assert_safe
+from .utils import IsoZapError, host_os, human_bytes, require_admin, validate_image
+from .windows_media import create_windows_media, inspect_windows_iso
+
+
+def parser() -> argparse.ArgumentParser:
+    result = argparse.ArgumentParser(
+        prog="isozap",
+        description="Create bootable USB drives safely from your terminal.",
+    )
+    result.add_argument("image", nargs="?", type=Path, help="ISO or IMG file")
+    result.add_argument("--type", choices=("windows", "hybrid", "raw"), dest="image_type", help="image creation method")
+    result.add_argument("--arch", choices=("x64", "arm64"), default="x64", help="Windows target architecture")
+    result.add_argument("--device", help="whole target device; must be detected as removable/external")
+    result.add_argument("--sha256", dest="expected_hash", help="verify the source's publisher-provided SHA-256")
+    result.add_argument("--verify-write", action="store_true", help="read back and checksum a raw write")
+    result.add_argument("--dry-run", action="store_true", help="validate and show operations without changing a device")
+    result.add_argument("--list", action="store_true", help="list safe removable/external disks and exit")
+    result.add_argument("--yes-i-really-mean-it", action="store_true", help="non-interactive destructive confirmation")
+    result.add_argument("--version", action="version", version=f"IsoZap {__version__}")
+    return result
+
+
+def choose(prompt: str, values: list, render):
+    if not values:
+        raise IsoZapError("No safe removable USB disks were detected.")
+    print(prompt)
+    for index, value in enumerate(values, 1):
+        print(f"  {index}) {render(value)}")
+    while True:
+        try:
+            selected = int(input("Selection: "))
+            if 1 <= selected <= len(values):
+                return values[selected - 1]
+        except ValueError:
+            pass
+        print("Enter a number from the list.")
+
+
+def progress(label: str):
+    def report(done: int, total: int, elapsed: float) -> None:
+        speed = done / elapsed
+        end = "\n" if done == total else ""
+        print(
+            f"\r{label}: {done * 100 / total:6.2f}%  "
+            f"{human_bytes(done)} / {human_bytes(total)}  {human_bytes(int(speed))}/s",
+            end=end, flush=True,
+        )
+    return report
+
+
+def _select_disk(requested: str | None, disks: list[Disk]) -> Disk:
+    if requested:
+        matches = [item for item in disks if item.path.casefold() == requested.casefold()]
+        if not matches:
+            raise IsoZapError("Requested target is not in the safe whole removable-disk list.")
+        return matches[0]
+    return choose(
+        "Target USB (ALL DATA WILL BE DESTROYED):",
+        disks,
+        lambda item: f"{item.path} — {human_bytes(item.size)} — {item.name}",
+    )
+
+
+def _overview(system: str, image: Path, disk: Disk, image_type: str) -> None:
+    print("\nWARNING: ALL DATA ON THIS DEVICE WILL BE DESTROYED.\n")
+    print(f"Host OS:   {system}")
+    print(f"ISO/image: {image}")
+    print(f"ISO size:  {human_bytes(image.stat().st_size)}")
+    print(f"Device:    {disk.path}")
+    print(f"Model:     {disk.name}")
+    print(f"Size:      {human_bytes(disk.size)}")
+    print(f"External:  {'Yes' if disk.external else 'No'}")
+    print(f"Removable: {'Yes' if disk.removable else 'No'}")
+    print(f"Method:    {'FAT32 Windows installer preparation' if image_type == 'windows' else 'raw image write'}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parser().parse_args(argv)
+    try:
+        system = host_os()
+        disks = safe_disks()
+        if args.list:
+            if not disks:
+                print(f"No safe removable USB disks detected on {system}.")
+            for disk in disks:
+                print(f"{disk.path}\t{human_bytes(disk.size)}\t{disk.name}\t{disk.transport}")
+            return 0
+
+        image_input = args.image or Path(input("Path to ISO/IMG: ").strip().strip("\"'"))
+        image = validate_image(image_input)
+        image_type = args.image_type or choose("Image type:", ["windows", "hybrid", "raw"], str)
+        disk = _select_disk(args.device, disks)
+        disk = assert_safe(disk, image, safe_disks)
+
+        if args.expected_hash:
+            print("Verifying source SHA-256...")
+            actual = sha256(image)
+            if actual.casefold() != args.expected_hash.casefold():
+                raise IsoZapError(f"SHA-256 mismatch. Expected {args.expected_hash}, got {actual}.")
+            print("Source SHA-256 verified.")
+
+        needs_split = inspect_windows_iso(image, args.arch) if image_type == "windows" and not args.dry_run else False
+        _overview(system, image, disk, image_type)
+        if args.dry_run:
+            print("\nDRY RUN: safety checks passed; no device was unmounted, formatted, or written.")
+            if image_type == "windows":
+                print("Windows ISO structural mounting is deferred until an actual operation.")
+            return 0
+        if not args.yes_i_really_mean_it and input("\nType exactly ERASE to continue: ") != "ERASE":
+            print("Cancelled; no changes were made.")
+            return 0
+
+        require_admin()
+        disk = assert_safe(disk, image, safe_disks)
+        if image_type == "windows":
+            create_windows_media(image, disk, args.arch, needs_split)
+            print("Write completed; required Windows boot files were found on the USB.")
+        else:
+            verified = raw_write(
+                image, disk, progress("Writing"), verify=args.verify_write,
+                verify_progress=progress("Verifying"),
+            )
+            if args.verify_write:
+                if not verified:
+                    raise IsoZapError("Write completed, but read-back verification failed.")
+                print("Write completed and read-back SHA-256 verification passed.")
+            else:
+                print("Write completed. Read-back verification was not requested.")
+        print("The USB has been ejected where supported and can be removed safely.")
+        return 0
+    except KeyboardInterrupt:
+        print("\nCancelled by user.", file=sys.stderr)
+        return 130
+    except (IsoZapError, OSError, ValueError) as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

isozap-0.1.0/src/isozap/core.py

@@ -0,0 +1,22 @@
+"""Compatibility exports for IsoZap's original public module."""
+
+from .devices import safe_disks as list_disks
+from .flash import raw_write, sha256
+from .models import Disk
+from .platforms.windows import physical_drive_number
+from .utils import IsoZapError, host_os, human_bytes, require_admin, require_commands, run
+
+FAT32_MAX = 4_294_967_295
+WIM_SPLIT_MB = 3_800
+
+
+def validate_target(disk: Disk, image_size: int) -> None:
+    current = {item.path: item for item in list_disks()}
+    if disk.path not in current:
+        raise IsoZapError("The selected removable disk is no longer present or is no longer safe.")
+    if image_size > current[disk.path].size:
+        raise IsoZapError("The source image is larger than the selected disk.")
+
+
+def windows_loader(arch: str) -> str:
+    return "efi/boot/bootx64.efi" if arch == "x64" else "efi/boot/bootaa64.efi"