archive-extractor 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

archive_extractor/__init__.py

@@ -0,0 +1,118 @@
+"""Archive Extractor - Recursively extract ZIP and 7z archives.
+
+CLI Usage:
+    archive-extractor /path/to/search
+    archive-extractor /path/to/search --passwords passwords.txt
+
+Library Usage:
+    from archive_extractor import extract_archives
+
+    # Extract all archives in a directory
+    results = extract_archives("/path/to/search")
+
+    # Extract a single archive
+    results = extract_archives("/path/to/archive.zip")
+
+    # With passwords
+    results = extract_archives("/path/to/search", passwords=["pass1", "pass2"])
+
+    # Custom output directory
+    results = extract_archives("/path/to/search", output_dir="/path/to/output")
+
+    # Silent mode (no progress bars)
+    results = extract_archives("/path/to/search", show_progress=False)
+"""
+
+import argparse
+import os
+
+from .core import (
+    find_archive_files,
+    load_passwords,
+    extract_zip_archive,
+    extract_7z_archive,
+)
+
+__all__ = ["extract_archives"]
+
+
+def extract_archives(
+    path: str,
+    output_dir: str | None = None,
+    passwords: list[str] | None = None,
+    show_progress: bool = True
+) -> dict[str, int]:
+    """Extract all archives found at the given path.
+
+    Args:
+        path: Single archive file or directory to search for archives.
+        output_dir: Optional base directory for extraction output.
+            If None, each archive extracts to a sibling directory named after the archive.
+        passwords: Optional list of password strings to try for encrypted archives.
+        show_progress: Whether to show progress bars during extraction.
+
+    Returns:
+        Dictionary mapping archive paths to extraction counts.
+        A count of -1 indicates extraction failure.
+    """
+    results = {}
+
+    for archive_path in find_archive_files(path):
+        if output_dir:
+            archive_name = os.path.splitext(os.path.basename(archive_path))[0]
+            dest_dir = os.path.join(output_dir, archive_name)
+        else:
+            dest_dir = os.path.splitext(archive_path)[0]
+
+        ext = os.path.splitext(archive_path)[1].lower()
+
+        if ext == ".zip":
+            count = extract_zip_archive(archive_path, dest_dir, passwords, show_progress)
+        elif ext == ".7z":
+            count = extract_7z_archive(archive_path, dest_dir, passwords, show_progress)
+        else:
+            continue
+
+        results[archive_path] = count
+
+        if show_progress:
+            if count >= 0:
+                print(f"Extracted '{archive_path}' to '{dest_dir}'.")
+            else:
+                print(f"Could not extract '{archive_path}': no valid password found or archive is corrupt.")
+
+    return results
+
+
+def main():
+    """CLI entry point for archive-extractor."""
+    parser = argparse.ArgumentParser(
+        description="Recursively extract all files from .zip and .7z archives under a given path."
+    )
+    parser.add_argument(
+        "path",
+        help="Root directory or file to search for .zip/.7z files"
+    )
+    parser.add_argument(
+        "--passwords",
+        help="Path to a file containing passwords (one per line) to try for encrypted archives"
+    )
+    parser.add_argument(
+        "--output-dir",
+        help="Base directory for extraction output (default: sibling directory of each archive)"
+    )
+    parser.add_argument(
+        "--quiet", "-q",
+        action="store_true",
+        help="Suppress progress output"
+    )
+    args = parser.parse_args()
+
+    passwords = load_passwords(args.passwords) if args.passwords else None
+
+    extract_archives(
+        args.path,
+        output_dir=args.output_dir,
+        passwords=passwords,
+        show_progress=not args.quiet
+    )

archive_extractor/core.py

@@ -0,0 +1,160 @@
+"""Core extraction logic for archive-extractor."""
+
+import os
+import re
+import zipfile
+import lzma
+
+import py7zr
+from tqdm import tqdm
+
+
+def sanitize_filename(filename: str) -> str:
+    """Remove directories and illegal characters from a filename.
+
+    Args:
+        filename: The filename to sanitize.
+
+    Returns:
+        A safe filename with illegal characters replaced and path components removed.
+    """
+    filename = re.sub(r'[\\/*?:"<>|]', "_", filename)
+    filename = filename.replace("..", "")
+    return os.path.basename(filename)
+
+
+def find_archive_files(root_path: str):
+    """Recursively yield paths to all .zip and .7z files under root_path.
+
+    Args:
+        root_path: Directory to search, or a single archive file path.
+
+    Yields:
+        Absolute paths to archive files found.
+    """
+    if os.path.isfile(root_path):
+        ext = os.path.splitext(root_path)[1].lower()
+        if ext in ('.zip', '.7z'):
+            yield root_path
+        return
+
+    for dirpath, _, filenames in os.walk(root_path):
+        for fname in filenames:
+            if fname.lower().endswith('.zip') or fname.lower().endswith('.7z'):
+                yield os.path.join(dirpath, fname)
+
+
+def load_passwords(password_file: str) -> list[str]:
+    """Load passwords from a file, one per line, stripping whitespace.
+
+    Args:
+        password_file: Path to a file containing passwords.
+
+    Returns:
+        List of password strings.
+    """
+    with open(password_file, 'r', encoding='utf-8') as f:
+        return [line.strip() for line in f if line.strip()]
+
+
+def extract_zip_archive(
+    zip_file: str,
+    output_dir: str,
+    passwords: list[str] | None = None,
+    show_progress: bool = True
+) -> int:
+    """Extract a ZIP archive to the specified directory.
+
+    Args:
+        zip_file: Path to the ZIP file.
+        output_dir: Directory to extract files to.
+        passwords: Optional list of passwords to try for encrypted archives.
+        show_progress: Whether to show tqdm progress bar.
+
+    Returns:
+        Number of files extracted, or -1 on failure.
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    with zipfile.ZipFile(zip_file, 'r') as zf:
+        members = zf.infolist()
+        extracted_count = 0
+
+        def extract_members(pwd_bytes=None):
+            nonlocal extracted_count
+            iterator = tqdm(members, desc=f"Extracting {os.path.basename(zip_file)}", leave=False) if show_progress else members
+            for member in iterator:
+                if member.is_dir():
+                    continue
+                safe_member_path = os.path.normpath(member.filename)
+                if os.path.isabs(safe_member_path) or safe_member_path.startswith(".."):
+                    continue
+                out_path = os.path.join(output_dir, safe_member_path)
+                out_dir = os.path.dirname(out_path)
+                if not os.path.exists(out_dir):
+                    os.makedirs(out_dir)
+                with open(out_path, 'wb') as f:
+                    f.write(zf.read(member, pwd_bytes))
+                extracted_count += 1
+
+        if not passwords:
+            try:
+                extract_members()
+                return extracted_count
+            except RuntimeError:
+                return -1
+        else:
+            for pwd in passwords:
+                extracted_count = 0
+                try:
+                    extract_members(pwd.encode('utf-8'))
+                    return extracted_count
+                except RuntimeError:
+                    continue
+                except zipfile.BadZipFile:
+                    continue
+            return -1
+
+
+def extract_7z_archive(
+    archive_file: str,
+    output_dir: str,
+    passwords: list[str] | None = None,
+    show_progress: bool = True
+) -> int:
+    """Extract a 7z archive to the specified directory.
+
+    Args:
+        archive_file: Path to the 7z file.
+        output_dir: Directory to extract files to.
+        passwords: Optional list of passwords to try for encrypted archives.
+        show_progress: Whether to show tqdm progress bar (currently unused for 7z).
+
+    Returns:
+        Number of files extracted, or -1 on failure.
+    """
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    def try_extract(password=None):
+        with py7zr.SevenZipFile(archive_file, mode='r', password=password) as archive:
+            archive.extractall(path=output_dir)
+            return len(archive.getnames())
+
+    if not passwords:
+        try:
+            return try_extract()
+        except (py7zr.exceptions.PasswordRequired, py7zr.exceptions.Bad7zFile, lzma.LZMAError):
+            return -1
+        except Exception:
+            return -1
+    else:
+        for pwd in passwords:
+            try:
+                return try_extract(pwd)
+            except (py7zr.exceptions.PasswordRequired, py7zr.exceptions.Bad7zFile, lzma.LZMAError):
+                continue
+            except Exception:
+                continue
+        return -1

{archive_extractor-0.1.2.dist-info → archive_extractor-0.2.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: archive-extractor
-Version: 0.1.2
-Summary: 📦 Recursively extract ZIP and 7z archives from directory trees, with password-cracking support
+Version: 0.2.0
+Summary: Recursively extract ZIP and 7z archives from directory trees, with password-cracking support
 Author-email: Tiago Silva <eng.tiago.silva@gmail.com>
 License-File: LICENSE
 Requires-Python: >=3.12

archive_extractor-0.2.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+archive_extractor/__init__.py,sha256=TJK1mnnpytttyxk18NH3BPfknauDKP018mcSBSUMugM,3620
+archive_extractor/core.py,sha256=0_7eD2JGyxHLrh5wk-FanNBIw5jpYii6BAkzy0P2Fyg,5017
+archive_extractor-0.2.0.dist-info/METADATA,sha256=Pam1RoVoEa2lBZAZ_3eT4qZm09Zq13uAra0V2YwEFnA,304
+archive_extractor-0.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+archive_extractor-0.2.0.dist-info/entry_points.txt,sha256=0OXNU4FRaPKLaOQFlKVwtXEv_hrZHvOmTPZf7zv1dBg,61
+archive_extractor-0.2.0.dist-info/licenses/LICENSE,sha256=gTrdDdqFDu7VtWezebCYIHmebmc-XTVxqWTZGKvDux0,1068
+archive_extractor-0.2.0.dist-info/RECORD,,

archive_extractor-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+archive-extractor = archive_extractor:main

archive_extractor-0.1.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-main.py,sha256=qlje5PrHKnZyS1EIpD5aK2G26NdaCD0ZfHhX_Mk2kp4,5461
-archive_extractor-0.1.2.dist-info/METADATA,sha256=gbaY-yt-buB2MFKhlTP9QkVm0PbcbftK74azno5wzAQ,309
-archive_extractor-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-archive_extractor-0.1.2.dist-info/entry_points.txt,sha256=IuJfvHFM_0ztmmO8RnQ1ZrnVAhNTorGmpRT6CwDkuyM,48
-archive_extractor-0.1.2.dist-info/licenses/LICENSE,sha256=gTrdDdqFDu7VtWezebCYIHmebmc-XTVxqWTZGKvDux0,1068
-archive_extractor-0.1.2.dist-info/RECORD,,

archive_extractor-0.1.2.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-archive-extractor = main:main

main.py

@@ -1,131 +0,0 @@
-import os
-import re
-import argparse
-from tqdm import tqdm
-import zipfile
-import py7zr
-import lzma
-
-def sanitize_filename(filename):
-    # Remove directories and illegal characters
-    filename = re.sub(r'[\\/*?:"<>|]', "_", filename)
-    filename = filename.replace("..", "")  # extra safety
-    return os.path.basename(filename)
-
-def find_archive_files(root_path):
-    """Recursively yield paths to all .zip and .7z files under root_path."""
-    for dirpath, _, filenames in os.walk(root_path):
-        for fname in filenames:
-            if fname.lower().endswith('.zip') or fname.lower().endswith('.7z'):
-                yield os.path.join(dirpath, fname)
-
-def load_passwords(password_file):
-    """Load passwords from a file, one per line, stripping whitespace."""
-    with open(password_file, 'r', encoding='utf-8') as f:
-        return [line.strip() for line in f if line.strip()]
-
-def extract_zip(zip_file, output_dir, passwords=None):
-    if not os.path.exists(output_dir):
-        os.makedirs(output_dir)
-
-    with zipfile.ZipFile(zip_file, 'r') as zf:
-        members = zf.infolist()
-        extracted = False
-        if not passwords:
-            # No passwords provided, extract directly
-            for member in tqdm(members, desc=f"Extracting {os.path.basename(zip_file)}"):
-                if member.is_dir():
-                    continue
-                safe_member_path = os.path.normpath(member.filename)
-                if os.path.isabs(safe_member_path) or safe_member_path.startswith(".."):
-                    continue
-                out_path = os.path.join(output_dir, safe_member_path)
-                out_dir = os.path.dirname(out_path)
-                if not os.path.exists(out_dir):
-                    os.makedirs(out_dir)
-                with open(out_path, 'wb') as f:
-                    f.write(zf.read(member))
-            extracted = True
-        else:
-            # Try each password for the whole zip
-            for pwd in passwords:
-                try:
-                    for member in tqdm(members, desc=f"Extracting {os.path.basename(zip_file)}", leave=False):
-                        if member.is_dir():
-                            continue
-                        safe_member_path = os.path.normpath(member.filename)
-                        if os.path.isabs(safe_member_path) or safe_member_path.startswith(".."):
-                            continue
-                        out_path = os.path.join(output_dir, safe_member_path)
-                        out_dir = os.path.dirname(out_path)
-                        if not os.path.exists(out_dir):
-                            os.makedirs(out_dir)
-                        with open(out_path, 'wb') as f:
-                            f.write(zf.read(member, pwd.encode('utf-8')))
-                    extracted = True
-                    break  # Stop trying passwords after success
-                except RuntimeError:
-                    # Wrong password, try next
-                    continue
-                except zipfile.BadZipFile:
-                    continue
-        if not extracted:
-            print(f"❌ Could not extract '{zip_file}': no valid password found.")
-        else:
-            print(f"✅ Extracted {len(members)} items to '{output_dir}'.")
-
-def extract_7z(archive_file, output_dir, passwords=None):
-    if not os.path.exists(output_dir):
-        os.makedirs(output_dir)
-
-    extracted = False
-    if not passwords:
-        try:
-            with py7zr.SevenZipFile(archive_file, mode='r') as archive:
-                archive.extractall(path=output_dir)
-            extracted = True
-        except (py7zr.exceptions.PasswordRequired, py7zr.exceptions.Bad7zFile, lzma.LZMAError):
-            pass
-        except Exception:
-            pass
-    else:
-        for pwd in passwords:
-            try:
-                with py7zr.SevenZipFile(archive_file, mode='r', password=pwd) as archive:
-                    archive.extractall(path=output_dir)
-                extracted = True
-                break
-            except (py7zr.exceptions.PasswordRequired, py7zr.exceptions.Bad7zFile, lzma.LZMAError):
-                continue
-            except Exception:
-                continue
-    if not extracted:
-        print(f"❌ Could not extract '{archive_file}': no valid password found or archive is corrupt.")
-    else:
-        print(f"✅ Extracted '{archive_file}' to '{output_dir}'.")
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Recursively extract all files from .zip and .7z archives under a given path."
-    )
-    parser.add_argument(
-        "path",
-        help="Root directory or file to search for .zip/.7z files"
-    )
-    parser.add_argument(
-        "--passwords",
-        help="Path to a file containing passwords (one per line) to try for encrypted archives"
-    )
-    args = parser.parse_args()
-    root_path = args.path
-    passwords = load_passwords(args.passwords) if args.passwords else None
-    for archive_path in find_archive_files(root_path):
-        archive_dir = os.path.splitext(archive_path)[0]
-        ext = os.path.splitext(archive_path)[1].lower()
-        if ext == ".zip":
-            extract_zip(archive_path, archive_dir, passwords)
-        elif ext == ".7z":
-            extract_7z(archive_path, archive_dir, passwords)
-
-if __name__ == "__main__":
-    main()