feat(cli): add a simple cli

Implemented a new pybit7z command-line utility using argparse for argument parsing. The tool handles:

- Archive creation with multiple format support (7z, zip, tar, etc.)
- File extraction from compressed archives
- Detailed archive content listing
- Custom compression levels (0-9)
- Password protection for encrypted archives

Signed-off-by: msclock <[email protected]>

Author: msclock

pyproject.toml

@@ -32,6 +32,9 @@ dependencies = [
   "importlib_metadata>=1.4",
 ]
 
+[project.scripts]
+pybit7z = "pybit7z.cli:main"
+
 [project.optional-dependencies]
 test = ["pytest >=6", "pytest-cov >=3"]
 dev = ["pytest >=6", "pytest-cov >=3"]

src/pybit7z/cli.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import (
+    Bit7zLibrary,
+    BitArchiveReader,
+    BitArchiveWriter,
+    BitCompressionLevel,
+    BitInOutFormat,
+    FormatBZip2,
+    FormatGZip,
+    FormatSevenZip,
+    FormatTar,
+    FormatWim,
+    FormatXz,
+    FormatZip,
+    OverwriteMode,
+    lib7zip_context,
+)
+
+WRITABLE_FORMATS = {
+    "7z": FormatSevenZip,
+    "zip": FormatZip,
+    "tar": FormatTar,
+    "gzip": FormatGZip,
+    "bzip2": FormatBZip2,
+    "xz": FormatXz,
+    "wim": FormatWim,
+}
+
+
+def main() -> None:
+    """
+    Main function to parse command-line arguments and perform compression/decompression operations.
+    """
+    parser = argparse.ArgumentParser(
+        description="pybit7z command-line compression tool"
+    )
+    parser.add_argument(
+        "action",
+        choices=["compress", "decompress", "list"],
+        help="Operation type (compress/decompress/list)",
+    )
+    parser.add_argument("paths", nargs="+", help="File/directory paths to process")
+    parser.add_argument(
+        "-f",
+        "--format",
+        choices=WRITABLE_FORMATS.keys(),
+        default="7z",
+        help="Supported writable formats: 7z, zip, tar, gzip, bzip2, xz, wim",
+    )
+    output_group = parser.add_mutually_exclusive_group()
+    output_group.add_argument(
+        "-o",
+        "--output",
+        help="Output file/directory path (required for compress/decompress)",
+    )
+    output_group.add_argument(
+        "-v", "--verbose", action="store_true", help="Show detailed file information"
+    )
+    parser.add_argument("-p", "--password", help="Encryption password")
+    parser.add_argument(
+        "-l",
+        "--level",
+        type=str,
+        choices=BitCompressionLevel.__members__.keys(),
+        default=BitCompressionLevel.Nothing.value,
+        help="Compression level (%(choices)s)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        choices=OverwriteMode.__members__.keys(),
+        default=OverwriteMode.Overwrite.value,
+        help="Overwrite mode when output exists (%(choices)s)",
+    )
+
+    args = parser.parse_args()
+
+    if args.action in ["compress", "decompress"] and not args.output:
+        parser.error("Output file/directory path is required")
+
+    try:
+        with lib7zip_context() as lib:
+            if args.action == "compress":
+                compress(lib, args)
+            elif args.action == "decompress":
+                decompress(lib, args)
+            else:
+                list_archive(lib, args)
+    except Exception as e:  # pylint: disable=W0718
+        sys.stderr.write(f"Error: {e}\n")
+        sys.exit(1)
+
+
+def compress(lib: Bit7zLibrary, args: argparse.Namespace) -> None:
+    """
+    Compress files/directories into a specified archive format.
+    Args:
+        lib (Bit7zLibrary): The 7z library instance.
+        args (argparse.Namespace): Parsed command-line arguments.
+    """
+    fmt = WRITABLE_FORMATS[args.format]
+    assert isinstance(fmt, BitInOutFormat), (
+        f"Format {args.format} is not supported for compression"
+    )
+
+    writer = BitArchiveWriter(lib, fmt)
+
+    if args.password:
+        writer.set_password(args.password)
+
+    writer.set_compression_level(BitCompressionLevel(args.level))
+    writer.set_overwrite_mode(OverwriteMode(args.overwrite))
+
+    writer.add_items([path for path in args.paths if Path(path).exists()])
+
+    writer.compress_to(args.output)
+    sys.stdout.write(f"Successfully created archive: {args.output}")
+
+
+def decompress(lib: Bit7zLibrary, args: argparse.Namespace) -> None:
+    """
+    Decompress an archive to a specified directory.
+    Args:
+        lib (Bit7zLibrary): The 7z library instance.
+        args (argparse.Namespace): Parsed command-line arguments.
+    """
+    reader = BitArchiveReader(lib, args.paths[0])
+
+    if args.password:
+        reader.set_password(args.password)
+
+    reader.extract_to(args.output)
+    sys.stdout.write(f"Successfully extracted to: {args.output}")
+
+
+def list_archive(lib: Bit7zLibrary, args: argparse.Namespace) -> None:
+    """
+    List the contents of an archive.
+    Args:
+        lib (Bit7zLibrary): The 7z library instance.
+        args (argparse.Namespace): Parsed command-line arguments.
+    """
+    reader = BitArchiveReader(lib, args.paths[0])
+
+    if args.password:
+        reader.set_password(args.password)
+
+    # Printing archive metadata
+    sys.stdout.write(
+        f"Archive properties:\n  Items count: {reader.items_count()}\n"
+        f"  Folders count: {reader.folders_count()}\n"
+        f"  Files count: {reader.files_count()}\n"
+        f"  Size: {reader.size()}\n"
+        f"  Packed size: {reader.pack_size()}"
+    )
+
+    # Printing the metadata of the archived items
+    sys.stdout.write("Archived items")
+    for item in reader.items():
+        sys.stdout.write(
+            f"    Item index: {item.index()}\n"
+            f"    Name: {item.name()}\n"
+            f"    Extension: {item.extension()}\n"
+            f"    Path: {item.path()}\n"
+            f"    IsDir: {item.is_dir()}\n"
+            f"    Size: {item.size()}\n"
+            f"    Packed size: {item.pack_size()}\n"
+            f"    CRC: {item.crc()}"
+        )
+
+
+if __name__ == "__main__":
+    main()

tests/conftest.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import random
+import string
+import tempfile
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def temp_dir():
+    """Fixture to provide temporary directory"""
+    try:
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            yield Path(tmp_dir)
+    except Exception:
+        ...  # Ignore errors from cleanup
+
+
+@pytest.fixture
+def large_file(tmp_path):
+    """Fixture to create a large test file (10MB)"""
+    file_path: Path = tmp_path / "large_file.dat"
+    size_mb = 10
+    chunk_size = 1024 * 1024  # 1MB chunks
+
+    with file_path.open("wb") as f:
+        for _ in range(size_mb):
+            data = "".join(
+                random.choices(string.ascii_letters + string.digits, k=chunk_size)
+            ).encode()
+            f.write(data)
+
+    return file_path

tests/test_cli.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import subprocess
+
+
+def test_cli_help():
+    """Test the CLI help message"""
+    result = subprocess.run(
+        ["pybit7z", "--help"], capture_output=True, text=True, check=False
+    )
+    assert result.returncode == 0
+    assert "pybit7z command-line compression tool" in result.stdout
+
+
+def test_compress_basic(temp_dir):
+    """Test basic compression functionality"""
+    test_file = temp_dir / "test.txt"
+    test_file.write_text("sample content")
+    output = temp_dir / "test.7z"
+
+    result = subprocess.run(
+        ["pybit7z", "compress", str(test_file), "-o", str(output), "-f", "7z"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0
+    assert output.exists()
+    assert "Successfully created archive" in result.stdout
+
+
+def test_decompress_basic(temp_dir):
+    """Test basic decompression functionality"""
+    # Create test archive
+    test_file = temp_dir / "test.txt"
+    test_file.write_text("content")
+    archive = temp_dir / "test.7z"
+    subprocess.run(
+        ["pybit7z", "compress", str(test_file), "-o", str(archive)],
+        capture_output=True,
+        check=False,
+    )
+
+    # Test decompression
+    output_dir = temp_dir / "output"
+    result = subprocess.run(
+        ["pybit7z", "decompress", str(archive), "-o", str(output_dir)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0
+    assert (output_dir / test_file.name).exists()
+
+
+def test_invalid_format_handling(temp_dir):
+    """Test handling of invalid formats"""
+    test_file = temp_dir / "test.txt"
+    test_file.write_text("content")
+    output = temp_dir / "test.invalid"
+
+    result = subprocess.run(
+        ["pybit7z", "compress", str(test_file), "-o", str(output), "-f", "invalid"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode != 0
+    assert "error: argument -f/--format" in result.stderr
+
+
+def test_password_protection(temp_dir):
+    """Test password protection for compression and decryption"""
+    test_file = temp_dir / "secret.txt"
+    test_file.write_text("confidential")
+    output = temp_dir / "protected.7z"
+
+    # Compress with password
+    compress_cmd = [
+        "pybit7z",
+        "compress",
+        str(test_file),
+        "-o",
+        str(output),
+        "-p",
+        "mypassword",
+    ]
+    assert subprocess.run(compress_cmd, check=False).returncode == 0
+
+    # Decompress without password should fail
+    extract_dir = temp_dir / "extracted"
+    result = subprocess.run(
+        ["pybit7z", "decompress", str(output), "-o", str(extract_dir)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode != 0
+    assert "password" in result.stderr.lower()
+
+
+def test_list_output(temp_dir):
+    """
+    Test the 'list' command to ensure it correctly lists files in an archive.
+    """
+    # Create archive with multiple files
+    archive = temp_dir / "multi.7z"
+    files = [temp_dir / f"file{i}.txt" for i in range(3)]
+    for f in files:
+        f.write_text("data")
+
+    subprocess.run(
+        ["pybit7z", "compress"] + [str(f) for f in files] + ["-o", str(archive)],
+        capture_output=True,
+        check=False,
+    )
+
+    # Test archive listing
+    result = subprocess.run(
+        ["pybit7z", "list", str(archive)], capture_output=True, text=True, check=False
+    )
+
+    assert result.returncode == 0
+    for f in files:
+        assert f.name in result.stdout

tests/test_pybit7z.py

@@ -1,43 +1,13 @@
 from __future__ import annotations
 
 import datetime
-import random
-import string
-import tempfile
 from pathlib import Path
 
 import pytest
 
 import pybit7z
 
 
-@pytest.fixture
-def temp_dir():
-    """Fixture to provide temporary directory"""
-    try:
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            yield Path(tmp_dir)
-    except Exception:
-        ...  # Ignore errors from cleanup
-
-
-@pytest.fixture
-def large_file(temp_dir):
-    """Fixture to create a large test file (10MB)"""
-    file_path: Path = temp_dir / "large_file.dat"
-    size_mb = 10
-    chunk_size = 1024 * 1024  # 1MB chunks
-
-    with file_path.open("wb") as f:
-        for _ in range(size_mb):
-            data = "".join(
-                random.choices(string.ascii_letters + string.digits, k=chunk_size)
-            ).encode()
-            f.write(data)
-
-    return file_path
-
-
 def test_format():
     """Test format from bit7z"""
     assert pybit7z.FormatSevenZip.extension().endswith(".7z")