py-zippy 1.0.0__py3-none-any.whl

zippy/create.py

@@ -0,0 +1,237 @@
+import bz2
+import gzip
+import lzma
+import os
+import posixpath
+import shutil
+import tarfile
+import zipfile
+
+try:
+    import pyzipper
+except ImportError:  # pragma: no cover - dependency declared; helpful fallback
+    pyzipper = None
+
+from .utils import (
+    get_logger,
+    handle_errors,
+    is_single_file_type,
+    loading_animation,
+    requires_external_tool,
+    tar_write_mode,
+    validate_path,
+    get_archive_type,
+)
+
+
+logger = get_logger("__name__")
+
+
+def _parse_input_files(files_to_add):
+    """Return a list of cleaned input paths."""
+    if isinstance(files_to_add, (list, tuple, set)):
+        raw_items = [str(item).strip() for item in files_to_add]
+    elif isinstance(files_to_add, str):
+        raw_items = [segment.strip() for segment in files_to_add.split(",")]
+    else:
+        handle_errors(
+            "Files to add must be provided as a string or iterable of strings."
+        )
+    cleaned = [item for item in raw_items if item]
+    if not cleaned:
+        handle_errors("No files specified to add to the archive.")
+    # Preserve input order while dropping duplicates.
+    return list(dict.fromkeys(cleaned))
+
+
+def _sanitize_arcname(original_path, absolute_path):
+    """Derive a safe archive name based on the provided input path."""
+    if os.path.isabs(original_path):
+        return os.path.basename(absolute_path).replace(os.sep, "/")
+    normalized = os.path.normpath(original_path)
+    while normalized.startswith(".." + os.sep):
+        normalized = normalized[3:]
+    normalized = normalized.lstrip("./")
+    sanitized = normalized or os.path.basename(absolute_path)
+    return sanitized.replace(os.sep, "/")
+
+
+def _iter_zip_entries(input_specs):
+    """Yield (source_path, arcname) tuples for zip creation."""
+    for original_path, absolute_path in input_specs:
+        arc_root = _sanitize_arcname(original_path, absolute_path)
+        if os.path.isdir(absolute_path):
+            # Ensure directory entries exist to preserve empty folders.
+            for root, dirs, files in os.walk(absolute_path):
+                rel_root = os.path.relpath(root, absolute_path)
+                if rel_root == ".":
+                    current_arc_root = arc_root
+                else:
+                    current_arc_root = posixpath.join(
+                        arc_root, rel_root.replace(os.sep, "/")
+                    )
+                yield None, current_arc_root.rstrip("/") + "/"
+                if not files and not dirs:
+                    continue
+                for file_name in files:
+                    file_path = os.path.join(root, file_name)
+                    arcname = posixpath.join(current_arc_root, file_name)
+                    yield file_path, arcname
+        else:
+            yield absolute_path, arc_root
+
+
+def _collect_input_specs(files_to_add):
+    cleaned = _parse_input_files(files_to_add)
+    specs = []
+    for item in cleaned:
+        absolute = validate_path(item, "File to add", must_exist=True)
+        specs.append((item, absolute))
+    return specs
+
+
+def _create_archive_internal(
+    archive_path, files_to_add, archive_type, password, verbose, disable_animation
+):
+    """
+    Internal function to create an archive with the specified files.
+
+    Parameters:
+    - archive_path (str): Path to the output archive file.
+    - files_to_add (str): Comma-separated list of files/directories to add to the archive.
+    - archive_type (str): Type of the archive (zip, tar, tar.gz, gzip).
+    - password (str): Password for encrypted archives (if applicable).
+    - verbose (bool): Enable verbose output for debugging.
+    - disable_animation (bool): Disable loading animation.
+
+    Raises:
+    - ValueError: If no files are specified to add to the archive.
+    - RuntimeError: If archive creation fails due to various issues.
+    """
+    specs = _collect_input_specs(files_to_add)
+    if not archive_type:
+        archive_type = get_archive_type(archive_path)
+        if not archive_type:
+            handle_errors(
+                "Could not infer archive type from output path. Please specify with --type (zip, tar, tar.gz, tar.bz2, tar.xz, tar.lzma, gzip, bz2, xz, lzma)."
+            )
+    try:
+        loading_animation(
+            f"Creating {os.path.basename(archive_path)}",
+            duration=2,
+            disable_animation=disable_animation,
+        )
+        if archive_type == "zip":
+            pwd = password.encode("utf-8") if password else None
+            if pwd:
+                if not pyzipper:
+                    handle_errors(
+                        "Password-protected ZIP creation requires the 'pyzipper' package. "
+                        "Install it or omit the password to create an unencrypted archive.",
+                        verbose,
+                    )
+                with pyzipper.AESZipFile(
+                    archive_path,
+                    "w",
+                    compression=zipfile.ZIP_DEFLATED,
+                    encryption=pyzipper.WZ_AES,
+                ) as zf:
+                    zf.pwd = pwd
+                    zf.setencryption(pyzipper.WZ_AES, nbits=256)
+                    for source_path, arcname in _iter_zip_entries(specs):
+                        if source_path is None:
+                            info = zipfile.ZipInfo(
+                                arcname if arcname.endswith("/") else arcname + "/"
+                            )
+                            info.external_attr = 0o755 << 16
+                            zf.writestr(info, b"")
+                            continue
+                        zf.write(source_path, arcname)
+            else:
+                with zipfile.ZipFile(
+                    archive_path, "w", compression=zipfile.ZIP_DEFLATED
+                ) as zf:
+                    for source_path, arcname in _iter_zip_entries(specs):
+                        if source_path is None:
+                            info = zipfile.ZipInfo(
+                                arcname if arcname.endswith("/") else arcname + "/"
+                            )
+                            info.external_attr = 0o755 << 16
+                            zf.writestr(info, b"")
+                            continue
+                        zf.write(source_path, arcname=arcname)
+        elif archive_type.startswith("tar"):
+            mode = tar_write_mode(archive_type)
+            if not mode:
+                handle_errors(f"Creation for {archive_type} is not supported.")
+            with tarfile.open(archive_path, mode) as tf:
+                for original_path, absolute_path in specs:
+                    arcname = _sanitize_arcname(original_path, absolute_path)
+                    tf.add(absolute_path, arcname=arcname)
+        elif is_single_file_type(archive_type):
+            if len(specs) != 1:
+                handle_errors(
+                    f"{archive_type} archives can only contain a single file. Please specify one file to compress."
+                )
+            _, input_file = specs[0]
+            if os.path.isdir(input_file):
+                handle_errors(
+                    f"{archive_type} archives cannot contain directories. Provide a single file."
+                )
+            with open(input_file, "rb") as infile:
+                if archive_type == "gzip":
+                    with gzip.open(archive_path, "wb") as gf:
+                        shutil.copyfileobj(infile, gf)
+                elif archive_type == "bz2":
+                    with bz2.open(archive_path, "wb") as bf:
+                        shutil.copyfileobj(infile, bf)
+                elif archive_type == "xz":
+                    with lzma.open(archive_path, "wb", format=lzma.FORMAT_XZ) as lf:
+                        shutil.copyfileobj(infile, lf)
+                elif archive_type == "lzma":
+                    with lzma.open(archive_path, "wb", format=lzma.FORMAT_ALONE) as lf:
+                        shutil.copyfileobj(infile, lf)
+                else:
+                    handle_errors(f"Creation for {archive_type} is not implemented.")
+        elif requires_external_tool(archive_type):
+            handle_errors(
+                f"Creation for {archive_type} archives requires external tooling (patool + backend binaries).",
+                verbose,
+            )
+        else:
+            handle_errors(f"Creation for {archive_type} not implemented.", verbose)
+        logger.info("Successfully created archive: %s", archive_path)
+    except Exception as e:
+        handle_errors(f"Archive creation failed: {e}", verbose)
+
+
+def create_archive(
+    archive_path,
+    files_to_add,
+    archive_type=None,
+    password=None,
+    verbose=False,
+    disable_animation=False,
+):
+    """
+    Creates an archive with the specified files.
+
+    Parameters:
+    - archive_path (str): Path to the output archive file.
+    - files_to_add (str): Comma-separated list of files/directories to add to the archive.
+    - archive_type (str): Type of the archive (zip, tar, tar.gz, gzip).
+    - password (str): Password for encrypted archives (if applicable).
+    - verbose (bool): Enable verbose output for debugging.
+    - disable_animation (bool): Disable loading animation.
+
+    Raises:
+    - ValueError: If no files are specified to add to the archive.
+    - RuntimeError: If archive creation fails due to various issues.
+    """
+    if not files_to_add:
+        files_to_add = input(
+            "Files to add not provided. Please enter the files to add (comma-separated): "
+        )
+    _create_archive_internal(
+        archive_path, files_to_add, archive_type, password, verbose, disable_animation
+    )

zippy/extract.py

@@ -0,0 +1,128 @@
+import bz2
+import gzip
+import lzma
+import os
+import shutil
+import tarfile
+import zipfile
+
+try:
+    import pyzipper
+except ImportError:  # pragma: no cover - optional dependency
+    pyzipper = None
+
+from .utils import (
+    get_logger,
+    get_archive_type,
+    handle_errors,
+    is_single_file_type,
+    loading_animation,
+    requires_external_tool,
+    external_extract,
+    tar_read_mode,
+)
+
+
+logger = get_logger(__name__)
+
+
+def _extract_with_pyzipper(archive_path, output_path, password, verbose):
+    if not pyzipper:
+        handle_errors(
+            "Archive uses an unsupported ZIP encryption method. Install 'pyzipper' to extract it.",
+            verbose,
+        )
+    if not password:
+        handle_errors("Password is required for encrypted ZIP archives.", verbose)
+    with pyzipper.AESZipFile(archive_path, "r") as zf:
+        zf.pwd = password.encode("utf-8")
+        zf.extractall(output_path)
+
+
+def extract_archive(
+    archive_path, output_path=".", password=None, verbose=False, disable_animation=False
+):
+    """
+    Extracts the contents of an archive to the specified output directory.
+
+    Parameters:
+    - archive_path (str): Path to the archive file.
+    - output_path (str): Directory where the contents will be extracted.
+    - password (str): Password for encrypted archives (if applicable).
+    - verbose (bool): Enable verbose output for debugging.
+    - disable_animation (bool): Disable loading animation.
+
+    Raises:
+    - ValueError: If the archive type is unsupported.
+    - RuntimeError: If extraction fails due to incorrect password or other issues.
+    """
+    if not output_path:
+        output_path = input(
+            "Output directory not provided. Please enter the output directory: "
+        )
+    archive_type = get_archive_type(archive_path)
+    if not archive_type:
+        handle_errors(f"Unsupported archive type for: {archive_path}")
+    output_path = os.path.abspath(output_path)
+    os.makedirs(output_path, exist_ok=True)
+    try:
+        loading_animation(
+            f"Extracting {os.path.basename(archive_path)} to {output_path}",
+            duration=2,
+            disable_animation=disable_animation,
+        )
+        if archive_type == "zip":
+            try:
+                with zipfile.ZipFile(archive_path, "r") as zf:
+                    zf.extractall(
+                        output_path, pwd=password.encode("utf-8") if password else None
+                    )
+            except RuntimeError as e:
+                lower = str(e).lower()
+                if "password" in lower:
+                    handle_errors("Incorrect password for ZIP archive.", verbose)
+                elif "compression method" in lower or "requires" in lower:
+                    _extract_with_pyzipper(archive_path, output_path, password, verbose)
+                else:
+                    handle_errors(f"ZIP Extraction error: {e}", verbose)
+            except NotImplementedError:
+                _extract_with_pyzipper(archive_path, output_path, password, verbose)
+        elif archive_type.startswith("tar"):
+            mode = tar_read_mode(archive_type)
+            with tarfile.open(archive_path, mode) as tf:
+                try:
+                    tf.extractall(output_path)
+                except tarfile.ReadError as e:
+                    handle_errors(f"TAR Extraction error: {e}", verbose)
+        elif is_single_file_type(archive_type):
+            output_file = os.path.join(
+                output_path,
+                os.path.splitext(os.path.basename(archive_path))[0],
+            )
+            if archive_type == "gzip":
+                opener = gzip.open
+                open_kwargs = {}
+            elif archive_type == "bz2":
+                opener = bz2.open
+                open_kwargs = {}
+            elif archive_type == "xz":
+                opener = lzma.open
+                open_kwargs = {"format": lzma.FORMAT_XZ}
+            elif archive_type == "lzma":
+                opener = lzma.open
+                open_kwargs = {"format": lzma.FORMAT_ALONE}
+            else:
+                handle_errors(
+                    f"Extraction for {archive_type} not implemented.", verbose
+                )
+                return
+            with opener(archive_path, "rb", **open_kwargs) as compressed:
+                with open(output_file, "wb") as outfile:
+                    shutil.copyfileobj(compressed, outfile)
+        elif requires_external_tool(archive_type):
+            external_extract(archive_path, output_path, verbose=verbose)
+        else:
+            handle_errors(f"Extraction for {archive_type} not implemented.", verbose)
+        logger.info("Successfully extracted to: %s", output_path)
+    except Exception as e:
+        handle_errors(f"Extraction failed: {e}", verbose)

zippy/list.py

@@ -0,0 +1,68 @@
+import os
+import tarfile
+import zipfile
+
+from .utils import (
+    Fore,
+    color_text,
+    get_logger,
+    get_archive_type,
+    handle_errors,
+    is_single_file_type,
+    loading_animation,
+    requires_external_tool,
+    external_list,
+    tar_read_mode,
+)
+
+
+logger = get_logger(__name__)
+
+
+def list_archive_contents(archive_path, verbose=False, disable_animation=False):
+    """
+    Lists the contents of an archive.
+
+    Parameters:
+    - archive_path (str): Path to the archive file.
+    - verbose (bool): Enable verbose output for debugging.
+    - disable_animation (bool): Disable loading animation.
+
+    Raises:
+    - ValueError: If the archive type is unsupported.
+    - RuntimeError: If listing fails due to various issues.
+    """
+    archive_type = get_archive_type(archive_path)
+    if not archive_type:
+        handle_errors(f"Unsupported archive type for: {archive_path}")
+    try:
+        loading_animation(
+            f"Listing contents of {os.path.basename(archive_path)}",
+            duration=1,
+            disable_animation=disable_animation,
+        )
+        heading = color_text(
+            f"\nContents of {archive_path}:\n", Fore.MAGENTA if Fore else None
+        )
+        print(heading)
+        if archive_type == "zip":
+            with zipfile.ZipFile(archive_path, "r") as zf:
+                for name in zf.namelist():
+                    print(color_text(name, Fore.GREEN if Fore else None))
+        elif archive_type.startswith("tar"):
+            mode = tar_read_mode(archive_type)
+            with tarfile.open(archive_path, mode) as tf:
+                for member in tf.getnames():
+                    print(color_text(member, Fore.GREEN if Fore else None))
+        elif is_single_file_type(archive_type):
+            msg = "Single-file compression detected. Use 'extract' to materialise the payload."
+            print(color_text(msg, Fore.YELLOW if Fore else None))
+        elif requires_external_tool(archive_type):
+            for line in external_list(archive_path, verbose=verbose):
+                print(color_text(line, Fore.GREEN if Fore else None))
+        else:
+            handle_errors(
+                f"Listing contents for {archive_type} not implemented.", verbose
+            )
+    except Exception as e:
+        handle_errors(f"Failed to list archive contents: {e}", verbose)

zippy/lock.py

@@ -0,0 +1,104 @@
+import os
+import shutil
+
+from .utils import (
+    Fore,
+    color_text,
+    extract_archive,
+    get_logger,
+    get_password_interactive,
+    handle_errors,
+    loading_animation,
+    create_archive,
+)
+
+
+logger = get_logger(__name__)
+
+
+def lock_archive(
+    archive_path,
+    files_to_add=None,
+    archive_type="zip",
+    password=None,
+    verbose=False,
+    disable_animation=False,
+):
+    """
+    Creates a password-protected ZIP archive or re-locks an existing archive with a new password.
+
+    Parameters:
+    - archive_path (str): Path to the archive file.
+    - files_to_add (str): Comma-separated list of files/directories to add to the archive.
+    - archive_type (str): Type of the archive (default: "zip").
+    - password (str): Password for the archive.
+    - verbose (bool): Enable verbose output for debugging.
+    - disable_animation (bool): Disable loading animation.
+
+    Raises:
+    - ValueError: If the archive type is unsupported or no files are specified.
+    - RuntimeError: If locking fails due to incorrect password or other issues.
+    """
+    if archive_type != "zip":
+        handle_errors(
+            "Locking (password protection) is only supported for ZIP archives."
+        )
+    if not password:
+        password = get_password_interactive()
+    if not files_to_add:
+        files_to_add = input(
+            "Files to add not provided. Please enter the files to add (comma-separated): "
+        )
+    if files_to_add:
+        logger.debug("Locking archive '%s' with provided file list.", archive_path)
+        create_archive(
+            archive_path,
+            files_to_add,
+            archive_type,
+            password,
+            verbose,
+            disable_animation,
+        )
+    else:
+        if not os.path.exists(archive_path):
+            handle_errors(
+                f"Archive file not found: {archive_path}. Cannot lock a non-existent archive."
+            )
+        temp_dir = "zippsnipp_temp_relock"
+        os.makedirs(temp_dir, exist_ok=True)
+        try:
+            loading_animation(
+                f"Re-locking {os.path.basename(archive_path)} with password",
+                duration=2,
+                disable_animation=disable_animation,
+            )
+            extract_archive(
+                archive_path, temp_dir, verbose=verbose, disable_animation=True
+            )
+            extracted_items = sorted(os.listdir(temp_dir))
+            if not extracted_items:
+                handle_errors("Extracted archive is empty; nothing to lock.")
+            original_cwd = os.getcwd()
+            try:
+                os.chdir(temp_dir)
+                files_argument = ",".join(extracted_items)
+                create_archive(
+                    archive_path,
+                    files_argument,
+                    "zip",
+                    password,
+                    verbose,
+                    disable_animation=True,
+                )
+            finally:
+                os.chdir(original_cwd)
+            shutil.rmtree(temp_dir)
+            logger.info(
+                color_text(
+                    f"Successfully re-locked archive: {archive_path} (Password protected)",
+                    Fore.GREEN if Fore else None,
+                )
+            )
+        except Exception as e:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            handle_errors(f"Failed to re-lock archive: {e}", verbose)