package_sd.py

#!/usr/bin/env python3
import argparse
import os
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path


SEVEN_ZIP_ARGS = [
    "-t7z",
    "-ms=off",
    "-m0=LZMA:d=14",
]


def find_7z(explicit_path=None):
    if explicit_path:
        candidate = Path(explicit_path).expanduser()
        if candidate.is_file():
            return str(candidate)
        raise FileNotFoundError("7-Zip executable not found: {}".format(candidate))

    for name in ("7z", "7zz", "7za", "7zr"):
        found = shutil.which(name)
        if found:
            return found

    if os.name == "nt":
        for env_name in ("ProgramFiles", "ProgramFiles(x86)"):
            program_files = os.environ.get(env_name)
            if program_files:
                candidate = Path(program_files) / "7-Zip" / "7z.exe"
                if candidate.is_file():
                    return str(candidate)

    raise FileNotFoundError(
        "Could not find 7-Zip. Install 7-Zip, add 7z.exe to PATH, "
        "or pass --seven-zip /path/to/7z."
    )


def is_relative_to(path, parent):
    try:
        path.relative_to(parent)
        return True
    except ValueError:
        return False


def should_package(item):
    if item.name == "__pycache__":
        return False
    if item.is_file() and item.suffix == ".pyc":
        return False
    return True


def build_package(source_dir, output_file, seven_zip):
    source_dir = Path(source_dir).resolve()
    output_file = Path(output_file).resolve()

    if not source_dir.is_dir():
        raise NotADirectoryError("Source folder does not exist: {}".format(source_dir))

    source_items = [item for item in source_dir.iterdir() if should_package(item)]
    if not source_items:
        raise ValueError("Source folder is empty: {}".format(source_dir))

    if is_relative_to(output_file, source_dir):
        raise ValueError("Output file must be outside the source folder.")

    output_file.parent.mkdir(parents=True, exist_ok=True)
    source_names = sorted(item.name for item in source_items)

    with tempfile.TemporaryDirectory(prefix="sd-package-") as temp_dir:
        temp_output = Path(temp_dir) / output_file.name
        command = [
            seven_zip,
            "a",
            "-y",
            *SEVEN_ZIP_ARGS,
            str(temp_output),
            *source_names,
        ]

        subprocess.run(command, cwd=str(source_dir), check=True)

        if output_file.exists():
            output_file.unlink()

        shutil.move(str(temp_output), str(output_file))

    return output_file


def parse_args(argv):
    parser = argparse.ArgumentParser(
        description=(
            "Package the contents of an unpacked ArcGIS service definition folder "
            "into a .sd file using 7-Zip."
        )
    )
    parser.add_argument(
        "source_dir",
        help="Folder whose contents should become the root of the .sd archive.",
    )
    parser.add_argument(
        "output_file",
        nargs="?",
        help="Output .sd path. Defaults to <source_dir>.sd next to the folder.",
    )
    parser.add_argument(
        "--seven-zip",
        dest="seven_zip",
        help="Path to 7z.exe if it is not available on PATH.",
    )
    return parser.parse_args(argv)


def main(argv=None):
    args = parse_args(argv or sys.argv[1:])
    source_dir = Path(args.source_dir)
    output_file = (
        Path(args.output_file)
        if args.output_file
        else source_dir.parent / "{}.sd".format(source_dir.name)
    )

    try:
        seven_zip = find_7z(args.seven_zip)
        packaged = build_package(source_dir, output_file, seven_zip)
    except Exception as exc:
        print("ERROR: {}".format(exc), file=sys.stderr)
        return 1

    print("Created {}".format(packaged))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())