py7zz 0.1.0.dev22__py3-none-win_amd64.whl

py7zz/cli.py

@@ -0,0 +1,90 @@
+"""
+Command Line Interface Module
+
+Directly passes through to the official 7zz binary, ensuring users get complete official 7-Zip functionality.
+py7zz's value is in automatic binary management and providing Python API.
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+from .bundled_info import get_version_info
+from .core import find_7z_binary
+
+
+def print_version_info(format_type: str = "human") -> None:
+    """Print version information in specified format."""
+    try:
+        info = get_version_info()
+
+        if format_type == "json":
+            print(json.dumps(info, indent=2))
+        else:
+            print(f"py7zz version: {info['py7zz_version']}")
+            print(f"Bundled 7zz version: {info['bundled_7zz_version']}")
+            print(f"Release type: {info['release_type']}")
+            print(f"Release date: {info['release_date']}")
+            print(f"GitHub tag: {info['github_tag']}")
+            print(f"Changelog: {info['changelog_url']}")
+    except Exception as e:
+        print(f"py7zz error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main() -> None:
+    """
+    Main entry point: Handle py7zz-specific commands or pass through to official 7zz
+
+    This ensures:
+    1. Users get complete official 7zz functionality
+    2. py7zz-specific commands are handled properly
+    3. No need to maintain parameter mapping and feature synchronization
+    4. py7zz focuses on Python API and binary management
+    """
+    try:
+        # Handle py7zz-specific commands
+        if len(sys.argv) > 1:
+            command = sys.argv[1]
+
+            if command == "version":
+                # Handle version command
+                format_type = "human"
+                if len(sys.argv) > 2 and sys.argv[2] == "--format":
+                    if len(sys.argv) > 3:
+                        format_type = sys.argv[3]
+                    else:
+                        print("Error: --format requires a value (human or json)", file=sys.stderr)
+                        sys.exit(1)
+
+                print_version_info(format_type)
+                return
+
+            elif command in ["--py7zz-version", "-V"]:
+                # Handle quick version command
+                print_version_info("human")
+                return
+
+        # Get py7zz-managed 7zz binary
+        binary_path = find_7z_binary()
+
+        # Direct pass-through of all command line arguments
+        cmd = [binary_path] + sys.argv[1:]
+
+        # Use exec to replace current process, ensuring signal handling behavior is consistent with native 7zz
+        if os.name == "nt":  # Windows
+            # Use subprocess on Windows and wait for result
+            result = subprocess.run(cmd)
+            sys.exit(result.returncode)
+        else:  # Unix-like systems
+            # Use execv to replace process on Unix
+            os.execv(binary_path, cmd)
+
+    except Exception as e:
+        print(f"py7zz error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

py7zz/compression.py

@@ -0,0 +1,128 @@
+"""
+Compression Algorithm Interface Module
+
+Provides a simple interface similar to modern compression libraries for single-stream compression.
+This is a complement to SevenZipFile archive functionality, not a replacement.
+"""
+
+import tempfile
+from pathlib import Path
+from typing import Union
+
+from .core import run_7z
+
+
+def compress(data: Union[str, bytes], algorithm: str = "lzma2", level: int = 5) -> bytes:
+    """
+    Compress a single data block, similar to zstd.compress()
+
+    Args:
+        data: Data to compress
+        algorithm: Compression algorithm (lzma2, lzma, ppmd, bzip2, deflate)
+        level: Compression level (0-9)
+
+    Returns:
+        Compressed byte data
+    """
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+
+        # Write to temporary file
+        input_file = tmpdir_path / "input.dat"
+        input_file.write_bytes(data)
+
+        # Compress as 7z single-file archive
+        output_file = tmpdir_path / "output.7z"
+        args = [
+            "a",
+            str(output_file),
+            str(input_file),
+            f"-mx{level}",
+            f"-m0={algorithm}",
+            "-ms=off",  # Disable solid mode
+        ]
+
+        run_7z(args)
+
+        # Read compressed result
+        return output_file.read_bytes()
+
+
+def decompress(data: bytes) -> bytes:
+    """
+    Decompress a single data block, similar to zstd.decompress()
+
+    Args:
+        data: Compressed byte data
+
+    Returns:
+        Decompressed byte data
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir_path = Path(tmpdir)
+
+        # Write compressed data
+        input_file = tmpdir_path / "input.7z"
+        input_file.write_bytes(data)
+
+        # Decompress
+        output_dir = tmpdir_path / "output"
+        args = ["x", str(input_file), f"-o{output_dir}", "-y"]
+
+        run_7z(args)
+
+        # Find decompressed files
+        output_files = list(output_dir.glob("*"))
+        if not output_files:
+            raise ValueError("No files found in archive")
+
+        # Return first file's content
+        return output_files[0].read_bytes()
+
+
+class Compressor:
+    """
+    Compressor class, provides an interface similar to zstd.ZstdCompressor
+    """
+
+    def __init__(self, algorithm: str = "lzma2", level: int = 5):
+        self.algorithm = algorithm
+        self.level = level
+
+    def compress(self, data: Union[str, bytes]) -> bytes:
+        """Compress data"""
+        return compress(data, self.algorithm, self.level)
+
+
+class Decompressor:
+    """
+    Decompressor class, provides an interface similar to zstd.ZstdDecompressor
+    """
+
+    def decompress(self, data: bytes) -> bytes:
+        """Decompress data"""
+        return decompress(data)
+
+
+# Convenience functions, mimicking modern compression libraries
+def lzma2_compress(data: Union[str, bytes], level: int = 5) -> bytes:
+    """LZMA2 compression"""
+    return compress(data, "lzma2", level)
+
+
+def lzma2_decompress(data: bytes) -> bytes:
+    """LZMA2 decompression"""
+    return decompress(data)
+
+
+def bzip2_compress(data: Union[str, bytes], level: int = 5) -> bytes:
+    """BZIP2 compression"""
+    return compress(data, "bzip2", level)
+
+
+def bzip2_decompress(data: bytes) -> bytes:
+    """BZIP2 decompression"""
+    return decompress(data)

py7zz/config.py

@@ -0,0 +1,260 @@
+"""
+Configuration and Preset System
+
+Provides advanced configuration options and preset configurations
+for different use cases.
+"""
+
+from dataclasses import dataclass
+from typing import Any, List, Optional
+
+
+@dataclass
+class Config:
+    """
+    Advanced configuration for 7z operations.
+
+    This class allows fine-grained control over compression parameters.
+    """
+
+    # Compression settings
+    compression: str = "lzma2"  # lzma2, lzma, ppmd, bzip2, deflate
+    level: int = 5  # 0-9, higher = better compression
+    solid: bool = True  # Solid archive (better compression)
+
+    # Performance settings
+    threads: Optional[int] = None  # Number of threads (None = auto)
+    memory_limit: Optional[str] = None  # Memory limit (e.g., "1g", "512m")
+
+    # Security settings
+    password: Optional[str] = None  # Archive password
+    encrypt_filenames: bool = False  # Encrypt file names
+
+    # Advanced options
+    dictionary_size: Optional[str] = None  # Dictionary size (e.g., "32m")
+    word_size: Optional[int] = None  # Word size for LZMA
+    fast_bytes: Optional[int] = None  # Fast bytes for LZMA
+
+    def to_7z_args(self) -> List[str]:
+        """Convert config to 7z command line arguments."""
+        args = []
+
+        # Compression level
+        args.append(f"-mx{self.level}")
+
+        # Compression method
+        args.append(f"-m0={self.compression}")
+
+        # Solid archive
+        if not self.solid:
+            args.append("-ms=off")
+
+        # Threads
+        if self.threads is not None:
+            args.append(f"-mmt{self.threads}")
+
+        # Memory limit
+        if self.memory_limit:
+            args.append(f"-mmemuse={self.memory_limit}")
+
+        # Dictionary size
+        if self.dictionary_size:
+            args.append(f"-md={self.dictionary_size}")
+
+        # Word size
+        if self.word_size:
+            args.append(f"-mfb={self.word_size}")
+
+        # Fast bytes
+        if self.fast_bytes:
+            args.append(f"-mfb={self.fast_bytes}")
+
+        # Password
+        if self.password:
+            args.append(f"-p{self.password}")
+
+        # Encrypt filenames
+        if self.encrypt_filenames and self.password:
+            args.append("-mhe")
+
+        return args
+
+
+class Presets:
+    """
+    Predefined configurations for common use cases.
+    """
+
+    @staticmethod
+    def fast() -> Config:
+        """
+        Fast compression preset.
+
+        Optimized for speed over compression ratio.
+        Good for temporary files or when time is critical.
+        """
+        return Config(
+            compression="lzma2",
+            level=1,
+            solid=False,
+            threads=None,  # Use all available threads
+        )
+
+    @staticmethod
+    def balanced() -> Config:
+        """
+        Balanced preset (default).
+
+        Good balance between compression ratio and speed.
+        Suitable for most general-purpose compression tasks.
+        """
+        return Config(
+            compression="lzma2",
+            level=5,
+            solid=True,
+            threads=None,
+        )
+
+    @staticmethod
+    def backup() -> Config:
+        """
+        Backup preset.
+
+        Optimized for maximum compression ratio.
+        Good for long-term storage where space matters more than time.
+        """
+        return Config(
+            compression="lzma2",
+            level=7,
+            solid=True,
+            dictionary_size="64m",
+            threads=None,
+        )
+
+    @staticmethod
+    def ultra() -> Config:
+        """
+        Ultra compression preset.
+
+        Maximum compression ratio at the cost of speed.
+        Use when storage space is extremely limited.
+        """
+        return Config(
+            compression="lzma2",
+            level=9,
+            solid=True,
+            dictionary_size="128m",
+            word_size=64,
+            fast_bytes=64,
+            threads=1,  # Single thread for maximum compression
+        )
+
+    @staticmethod
+    def secure() -> Config:
+        """
+        Secure preset with encryption.
+
+        Balanced compression with password protection.
+        Note: Password must be set separately.
+        """
+        return Config(
+            compression="lzma2",
+            level=5,
+            solid=True,
+            encrypt_filenames=True,
+            # password must be set by user
+        )
+
+    @staticmethod
+    def compatibility() -> Config:
+        """
+        Compatibility preset.
+
+        Uses widely supported compression methods.
+        Good for archives that need to be opened on older systems.
+        """
+        return Config(
+            compression="deflate",
+            level=6,
+            solid=False,
+        )
+
+    @classmethod
+    def get_preset(cls, name: str) -> Config:
+        """
+        Get a preset configuration by name.
+
+        Args:
+            name: Preset name ("fast", "balanced", "backup", "ultra", "secure", "compatibility")
+
+        Returns:
+            Config object for the specified preset
+
+        Raises:
+            ValueError: If preset name is not recognized
+        """
+        presets = {
+            "fast": cls.fast,
+            "balanced": cls.balanced,
+            "backup": cls.backup,
+            "ultra": cls.ultra,
+            "secure": cls.secure,
+            "compatibility": cls.compatibility,
+        }
+
+        if name not in presets:
+            available = ", ".join(presets.keys())
+            raise ValueError(f"Unknown preset '{name}'. Available presets: {available}")
+
+        return presets[name]()
+
+    @classmethod
+    def list_presets(cls) -> List[str]:
+        """List all available preset names."""
+        return ["fast", "balanced", "backup", "ultra", "secure", "compatibility"]
+
+
+def create_custom_config(**kwargs: Any) -> Config:
+    """
+    Create a custom configuration with specified parameters.
+
+    Args:
+        **kwargs: Any Config parameters to override
+
+    Returns:
+        Config object with specified parameters
+
+    Example:
+        >>> config = create_custom_config(level=9, threads=4, password="secret")
+        >>> # Use with SevenZipFile or create_archive
+    """
+    return Config(**kwargs)
+
+
+def get_recommended_preset(purpose: str) -> Config:
+    """
+    Get recommended preset based on intended purpose.
+
+    Args:
+        purpose: Intended use ("temp", "backup", "distribution", "secure", "fast")
+
+    Returns:
+        Recommended Config object
+    """
+    recommendations = {
+        "temp": Presets.fast(),
+        "temporary": Presets.fast(),
+        "backup": Presets.backup(),
+        "archive": Presets.backup(),
+        "distribution": Presets.balanced(),
+        "share": Presets.balanced(),
+        "secure": Presets.secure(),
+        "encrypted": Presets.secure(),
+        "fast": Presets.fast(),
+        "quick": Presets.fast(),
+        "max": Presets.ultra(),
+        "maximum": Presets.ultra(),
+        "ultra": Presets.ultra(),
+    }
+
+    return recommendations.get(purpose.lower(), Presets.balanced())