pysfi 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

sfi/pdfcrypt/__init__.py

@@ -0,0 +1,30 @@
+"""PDF encryption/decryption utilities.
+
+This module provides functionality to encrypt and decrypt PDF files
+using strong encryption algorithms. It supports batch processing
+of multiple files with configurable passwords and security settings.
+"""
+
+from .pdfcrypt import (
+    PDFCryptConfig,
+    conf,
+    decrypt,
+    decrypt_pdf,
+    encrypt,
+    encrypt_pdf,
+    is_encrypted,
+    main,
+)
+
+__all__ = [
+    "PDFCryptConfig",
+    "conf",
+    "decrypt",
+    "decrypt_pdf",
+    "encrypt",
+    "encrypt_pdf",
+    "is_encrypted",
+    "main",
+]
+
+__version__ = "0.1.15"

sfi/pdfcrypt/pdfcrypt.py

@@ -0,0 +1,435 @@
+"""Function: Encrypt/decrypt all PDF files in the current directory.
+
+This module provides functionality to encrypt and decrypt PDF files
+using strong encryption algorithms. It supports batch processing
+of multiple files with configurable passwords and security settings.
+"""
+
+from __future__ import annotations
+
+import argparse
+import atexit
+import contextlib
+import json
+import logging
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass
+from functools import cached_property, partial
+from pathlib import Path
+from typing import Final
+
+import pypdf
+
+# Constants
+MIN_PASSWORD_LENGTH: Final[int] = 6
+CONFIG_FILE: Final[Path] = Path.home() / ".pysfi" / "pdfcrypt.json"
+CWD: Final[Path] = Path.cwd()
+
+logger = logging.getLogger(__name__)
+
+__version__ = "1.0.0"
+__build__ = "20260204"
+
+
+@dataclass
+class PDFCryptConfig:
+    """Configuration for PDF encryption/decryption operations."""
+
+    max_workers: int = 4
+    default_password: str = ""
+    output_suffix_encrypted: str = ".enc.pdf"
+    output_suffix_decrypted: str = ".dec.pdf"
+    _config_loaded: bool = False
+
+    def __post_init__(self) -> None:
+        """Initialize configuration and load from file if exists."""
+        if CONFIG_FILE.exists():
+            try:
+                config_data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+                for key, value in config_data.items():
+                    if hasattr(self, key):
+                        setattr(self, key, value)
+                self._config_loaded = True
+                logger.info("Configuration loaded successfully")
+            except (json.JSONDecodeError, TypeError, AttributeError) as e:
+                logger.warning(f"Failed to load configuration: {e}")
+                logger.info("Using default configuration")
+        else:
+            logger.info("Using default configuration")
+
+    def save(self) -> None:
+        """Save current configuration to file."""
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        config_dict = {
+            "max_workers": self.max_workers,
+            "default_password": self.default_password,
+            "output_suffix_encrypted": self.output_suffix_encrypted,
+            "output_suffix_decrypted": self.output_suffix_decrypted,
+        }
+        CONFIG_FILE.write_text(json.dumps(config_dict, indent=4), encoding="utf-8")
+        logger.info("Configuration saved successfully")
+
+    @cached_property
+    def is_configured(self) -> bool:
+        """Check if configuration has been loaded from file."""
+        return self._config_loaded
+
+    @cached_property
+    def config_summary(self) -> dict[str, str | int]:
+        """Get configuration summary for display/logging purposes."""
+        return {
+            "max_workers": self.max_workers,
+            "output_suffix_encrypted": self.output_suffix_encrypted,
+            "output_suffix_decrypted": self.output_suffix_decrypted,
+            "source": "loaded" if self._config_loaded else "default",
+        }
+
+
+# Global configuration instance
+conf = PDFCryptConfig()
+atexit.register(conf.save)
+
+
+def is_encrypted(filepath: Path) -> bool:
+    """Check if a PDF file is encrypted.
+
+    Args:
+        filepath: Path to the PDF file
+
+    Returns:
+        bool: True if file is encrypted, False otherwise
+    """
+    try:
+        return pypdf.PdfReader(filepath).is_encrypted
+    except Exception:
+        logger.error(f"Failed to check encryption status for {filepath}")
+        return False
+
+
+def _validate_password_strength(password: str) -> None:
+    """Validate password strength and log warnings if needed.
+
+    Args:
+        password: Password to validate
+    """
+    if len(password) < MIN_PASSWORD_LENGTH:
+        logger.warning(
+            f"Password length less than {MIN_PASSWORD_LENGTH} characters, "
+            f"recommend using a stronger password"
+        )
+
+
+def _setup_pdf_writer(reader: pypdf.PdfReader) -> pypdf.PdfWriter:
+    """Create and configure PDF writer with pages from reader.
+
+    Args:
+        reader: Source PDF reader
+
+    Returns:
+        Configured PDF writer
+    """
+    writer = pypdf.PdfWriter()
+    for page in reader.pages:
+        writer.add_page(page)
+    return writer
+
+
+def _handle_output_file_conflict(filepath: Path) -> None:
+    """Log warning if output file already exists.
+
+    Args:
+        filepath: Target file path
+    """
+    if filepath.exists():
+        logger.warning(f"Target file already exists, will overwrite: {filepath}")
+
+
+def _cleanup_resources(reader=None, writer=None) -> None:
+    """Clean up PDF resources properly.
+
+    Args:
+        reader: PDF reader to close
+        writer: PDF writer to close
+    """
+    if reader:
+        with contextlib.suppress(Exception):
+            reader.stream.close()
+    # pypdf.PdfWriter has no explicit close method
+    if writer:
+        with contextlib.suppress(Exception):
+            writer.close()
+
+
+def encrypt_pdf(
+    filepath: Path,
+    password: str,
+) -> tuple[Path, Path | None]:
+    """Encrypt a single PDF file.
+
+    Args:
+        filepath: Path to the PDF file to encrypt
+        password: Encryption password
+
+    Returns:
+        Tuple containing original file path and encrypted file path (if successful)
+    """
+    # Validate password strength
+    _validate_password_strength(password)
+
+    reader = None
+    writer = None
+    enc_pdf_file = filepath.with_suffix(conf.output_suffix_encrypted)
+
+    try:
+        # Use context manager to ensure resource cleanup
+        with filepath.open("rb") as input_file:
+            reader = pypdf.PdfReader(input_file)
+            writer = _setup_pdf_writer(reader)
+
+            writer.encrypt(
+                user_password=password,
+                owner_password=password,
+                use_128bit=True,
+            )
+
+            # Check if target file already exists
+            _handle_output_file_conflict(enc_pdf_file)
+
+            with enc_pdf_file.open("wb") as output_file:
+                writer.write(output_file)
+    except OSError:
+        logger.exception(f"Failed to write encrypted file [{enc_pdf_file.name}]")
+        return filepath, None
+    except Exception:
+        logger.exception(f"Error encrypting file [{filepath.name}]")
+        return filepath, None
+    else:
+        logger.info(f"Successfully encrypted file: {enc_pdf_file}")
+        return filepath, enc_pdf_file
+    finally:
+        # Explicitly clean up resources
+        _cleanup_resources(reader, writer)
+
+
+def _attempt_pdf_decryption(
+    reader: pypdf.PdfReader, password: str, filepath: Path
+) -> bool:
+    """Attempt to decrypt PDF file and log results.
+
+    Args:
+        reader: PDF reader instance
+        password: Decryption password
+        filepath: Path to the PDF file
+
+    Returns:
+        True if decryption successful, False otherwise
+    """
+    if reader.decrypt(password):
+        logger.info(f"Successfully decrypted file [{filepath.name}]!")
+        return True
+    else:
+        logger.error(f"Failed to decrypt file [{filepath.name}], incorrect password.")
+        return False
+
+
+def _copy_pdf_pages(reader: pypdf.PdfReader) -> pypdf.PdfWriter:
+    """Copy all pages from reader to a new writer.
+
+    Args:
+        reader: Source PDF reader
+
+    Returns:
+        PDF writer with copied pages
+    """
+    writer = pypdf.PdfWriter()
+    for page_num in range(len(reader.pages)):
+        page = reader.pages[page_num]
+        writer.add_page(page)
+    return writer
+
+
+def decrypt_pdf(
+    filepath: Path,
+    password: str,
+) -> tuple[Path, Path | None]:
+    """Decrypt a PDF file.
+
+    Args:
+        filepath: Path to the PDF file to decrypt
+        password: Decryption password
+
+    Returns:
+        Tuple containing original file path and decrypted file path (if successful)
+    """
+    reader = None
+    writer = None
+
+    try:
+        # Open the input PDF file
+        with filepath.open("rb") as f:
+            reader = pypdf.PdfReader(f)
+
+            # Try to decrypt the file
+            if not _attempt_pdf_decryption(reader, password, filepath):
+                return filepath, None
+
+            # Create a new PdfWriter object and copy pages
+            writer = _copy_pdf_pages(reader)
+
+            # Write the decrypted PDF to output file
+            outfile = filepath.with_suffix(conf.output_suffix_decrypted)
+
+            # Check if target file already exists
+            _handle_output_file_conflict(outfile)
+
+            with outfile.open("wb") as output_file:
+                writer.write(output_file)
+                logger.info(f"Wrote decrypted file to [{outfile}]")
+                return filepath, outfile
+
+    except OSError:
+        logger.exception("Failed to write decrypted file")
+        return filepath, None
+    except Exception:
+        logger.exception(f"Error decrypting file [{filepath.name}]")
+        return filepath, None
+    finally:
+        # Explicitly clean up resources
+        _cleanup_resources(reader, writer)
+
+
+def list_pdf() -> tuple[list[Path], list[Path]]:
+    """List PDF files in current directory.
+
+    Returns:
+        Tuple containing lists of unencrypted and encrypted PDF files
+    """
+    un_encrypted = [_ for _ in CWD.rglob("*.pdf") if not is_encrypted(_)]
+    encrypted = [_ for _ in CWD.rglob("*.pdf") if is_encrypted(_)]
+
+    logger.info(f"Encrypted files: [green bold]{encrypted}")
+    logger.info(f"Unencrypted files: [green bold]{un_encrypted}")
+    return un_encrypted, encrypted
+
+
+def run_batch(func, files: list[Path]) -> None:
+    """Run function on multiple files concurrently.
+
+    Args:
+        func: Function to apply to each file
+        files: List of files to process
+    """
+    if not files:
+        logger.info("No files to process")
+        return
+
+    logger.info(f"Processing {len(files)} files...")
+
+    with ThreadPoolExecutor(max_workers=conf.max_workers) as executor:
+        # Submit all tasks
+        future_to_file = {executor.submit(func, file): file for file in files}
+
+        # Process completed tasks
+        for future in as_completed(future_to_file):
+            file = future_to_file[future]
+            try:
+                result = future.result()
+                if result[1]:  # If processing was successful
+                    logger.info(f"Completed: {file.name}")
+                else:
+                    logger.error(f"Failed: {file.name}")
+            except Exception as e:
+                logger.error(f"Error processing {file.name}: {e}")
+
+
+def decrypt(password: str) -> None:
+    """Execute decryption operation.
+
+    Args:
+        password: Decryption password
+    """
+    _, encrypted_files = list_pdf()
+    if not encrypted_files:
+        logger.error(f"No encrypted PDF files found in directory: {CWD}")
+        return
+
+    dec_func = partial(decrypt_pdf, password=password)
+    run_batch(dec_func, encrypted_files)
+
+
+def encrypt(password: str) -> None:
+    """Execute encryption operation.
+
+    Args:
+        password: Encryption password
+    """
+    unencrypted_files, _ = list_pdf()
+    if not unencrypted_files:
+        logger.error(f"No unencrypted PDF files found in directory: {CWD}")
+        return
+
+    enc_func = partial(encrypt_pdf, password=password)
+    run_batch(enc_func, unencrypted_files)
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments.
+
+    Returns:
+        Parsed arguments namespace
+    """
+    parser = argparse.ArgumentParser(
+        description="Encrypt/decrypt PDF files in current directory",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  pdfcrypt encrypt mypassword           # Encrypt all unencrypted PDFs
+  pdfcrypt decrypt mypassword           # Decrypt all encrypted PDFs
+  pdfcrypt --help                       # Show this help message
+        """,
+    )
+
+    parser.add_argument(
+        "action",
+        choices=["encrypt", "decrypt"],
+        help="Action to perform: encrypt or decrypt PDF files",
+    )
+
+    parser.add_argument("password", help="Password for encryption/decryption")
+
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=4,
+        help="Number of concurrent workers (default: 4)",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__} (build {__build__})",
+    )
+
+    return parser.parse_args()
+
+
+def main() -> None:
+    """Main entry point for the pdfcrypt CLI tool."""
+    args = parse_args()
+
+    # Update configuration
+    conf.max_workers = args.workers
+    conf.default_password = args.password
+
+    # Execute requested action
+    if args.action == "encrypt":
+        encrypt(args.password)
+    elif args.action == "decrypt":
+        decrypt(args.password)
+    else:
+        logger.error(f"Unknown action: {args.action}")
+
+
+if __name__ == "__main__":
+    main()

sfi/pdfsplit/pdfsplit.py

@@ -7,7 +7,6 @@ from pathlib import Path
 import fitz
 
 logging.basicConfig(level=logging.INFO, format="%(message)s")
-cwd = Path.cwd()
 logger = logging.getLogger(__name__)
 
 
@@ -50,7 +49,9 @@ def split_by_number(input_file: Path, output_file: Path, number: int) -> None:
 
         end_page = min(current_page + pages_in_this_part, total_pages)
 
-        part_file = output_file.parent / f"{output_file.stem}_part{i + 1}{output_file.suffix}"
+        part_file = (
+            output_file.parent / f"{output_file.stem}_part{i + 1}{output_file.suffix}"
+        )
         part_doc = fitz.open()
 
         for page_num in range(current_page, end_page):
@@ -58,7 +59,9 @@ def split_by_number(input_file: Path, output_file: Path, number: int) -> None:
 
         part_doc.save(part_file)
         part_doc.close()
-        logger.info(f"Created part {i + 1}: {part_file} (pages {current_page + 1}-{end_page})")
+        logger.info(
+            f"Created part {i + 1}: {part_file} (pages {current_page + 1}-{end_page})"
+        )
 
         current_page = end_page
 
@@ -77,7 +80,10 @@ def split_by_size(input_file: Path, output_file: Path, size: int) -> None:
 
     while start_page < total_pages:
         end_page = min(start_page + size, total_pages)
-        part_file = output_file.parent / f"{output_file.stem}_part{part + 1}{output_file.suffix}"
+        part_file = (
+            output_file.parent
+            / f"{output_file.stem}_part{part + 1}{output_file.suffix}"
+        )
         part_doc = fitz.open()
 
         for page_num in range(start_page, end_page):
@@ -85,7 +91,9 @@ def split_by_size(input_file: Path, output_file: Path, size: int) -> None:
 
         part_doc.save(part_file)
         part_doc.close()
-        logger.info(f"Created part {part + 1}: {part_file} (pages {start_page + 1}-{end_page})")
+        logger.info(
+            f"Created part {part + 1}: {part_file} (pages {start_page + 1}-{end_page})"
+        )
 
         start_page = end_page
         part += 1
@@ -122,18 +130,37 @@ def split_by_range(input_file: Path, output_file: Path, range_str: str) -> None:
 
 
 def main() -> None:
+    """Main entry point for pdfsplit CLI."""
     parser = argparse.ArgumentParser(description="Split PDF files")
     parser.add_argument("input", help="Input PDF file")
-    parser.add_argument("output", nargs="?", help="Output PDF file (optional for -n and -s modes)")
-    parser.add_argument("-o", "--output-dir", default=str(cwd), help="Output directory (default: current directory)")
-    parser.add_argument("-f", "--output-format", help="Output file format pattern, e.g., 'split_{part:02d}.pdf'")
+    parser.add_argument(
+        "output", nargs="?", help="Output PDF file (optional for -n and -s modes)"
+    )
+    parser.add_argument(
+        "-o",
+        "--output-dir",
+        default=".",
+        help="Output directory (default: current directory)",
+    )
+    parser.add_argument(
+        "-f",
+        "--output-format",
+        help="Output file format pattern, e.g., 'split_{part:02d}.pdf'",
+    )
     parser.add_argument("-v", "--verbose", action="store_true", help="Verbose output")
 
     # Split by number, size, or range
     group = parser.add_mutually_exclusive_group(required=True)
     group.add_argument("-n", "--number", type=int, help="Number of splits")
-    group.add_argument("-s", "--size", type=int, default=1, help="Size of each split in pages")
-    group.add_argument("-r", "--range", type=str, help="Range of pages to extract, e.g., '1,2,4-10,15-20,25-'")
+    group.add_argument(
+        "-s", "--size", type=int, default=1, help="Size of each split in pages"
+    )
+    group.add_argument(
+        "-r",
+        "--range",
+        type=str,
+        help="Range of pages to extract, e.g., '1,2,4-10,15-20,25-'",
+    )
 
     args = parser.parse_args()
 
@@ -142,7 +169,9 @@ def main() -> None:
 
     output_dir = Path(args.output_dir)
     if not output_dir.is_dir():
-        logger.error(f"Output directory {args.output_dir} does not exist, please check the path.")
+        logger.error(
+            f"Output directory {args.output_dir} does not exist, please check the path."
+        )
         return
 
     input_file = Path(args.input)
@@ -157,7 +186,11 @@ def main() -> None:
         return
 
     if not args.range:
-        output_file = output_dir / (input_file.stem + "_split.pdf") if not args.output else Path(args.output)
+        output_file = (
+            output_dir / (input_file.stem + "_split.pdf")
+            if not args.output
+            else Path(args.output)
+        )
     else:
         output_file = Path(args.output)
 

sfi/pyarchive/__init__.py

@@ -1 +1 @@
- 
+ 

sfi/pyarchive/pyarchive.py

@@ -312,7 +312,7 @@ class PyArchiver:
     @cached_property
     def solution(self) -> Solution:
         """Get the solution from the target directory."""
-        return Solution.from_directory(self.root_dir, update=True)
+        return Solution.from_directory(self.root_dir)
 
     @cached_property
     def projects(self) -> dict[str, Project]:

sfi/pyembedinstall/pyembedinstall.py

@@ -456,7 +456,7 @@ class EmbedInstaller:
     @cached_property
     def solution(self) -> Solution:
         """Get the solution from the target directory."""
-        return Solution.from_directory(self.root_dir, update=True)
+        return Solution.from_directory(self.root_dir)
 
     @cached_property
     def arch(self) -> str:

sfi/pylibpack/pylibpack.py

@@ -54,7 +54,7 @@ DEFAULT_MAX_WORKERS: Final[int] = 4
 DEFAULT_MIRROR: Final[str] = "aliyun"
 DEFAULT_OPTIMIZE: Final[bool] = True
 
-PYPI_MIRRORS = {
+PYPI_MIRRORS: Final[dict[str, str]] = {
     "pypi": "https://pypi.org/simple",
     "tsinghua": "https://pypi.tuna.tsinghua.edu.cn/simple",
     "aliyun": "https://mirrors.aliyun.com/pypi/simple/",
@@ -915,14 +915,10 @@ class LibraryCache:
     @staticmethod
     def _should_skip_dist_info(file_path: Path) -> bool:
         """Check if the file path should be skipped because it's a dist-info directory."""
-        name = file_path.name
-        if name.endswith(".dist-info"):
+        if file_path.name.endswith(".dist-info"):
             return True
         # Check if any parent directory ends with .dist-info
-        for part in file_path.parts:
-            if part.endswith(".dist-info"):
-                return True
-        return False
+        return any(part.endswith(".dist-info") for part in file_path.parts)
 
     def clear_cache(self) -> None:
         """Clear all cached packages."""
@@ -1410,14 +1406,10 @@ class PyLibPacker:
     @staticmethod
     def _should_skip_dist_info(file_path: Path) -> bool:
         """Check if the file path should be skipped because it's a dist-info directory."""
-        name = file_path.name
-        if name.endswith(".dist-info"):
+        if file_path.name.endswith(".dist-info"):
             return True
         # Check if any parent directory ends with .dist-info
-        for part in file_path.parts:
-            if part.endswith(".dist-info"):
-                return True
-        return False
+        return any(part.endswith(".dist-info") for part in file_path.parts)
 
     def run(self) -> None:
         """Pack project dependencies from base directory with concurrent processing."""

sfi/pyloadergen/pyloadergen.py

@@ -967,8 +967,10 @@ class EntryFile:
         try:
             content = self.source_file.read_text(encoding="utf-8")
             gui_keywords = ["pyside2", "pyqt5", "pyqt6", "tkinter", "tkinter.ttk"]
-            return any(f"from {kw}" in content.lower() or f"import {kw}" in content.lower()
-                      for kw in gui_keywords)
+            return any(
+                f"from {kw}" in content.lower() or f"import {kw}" in content.lower()
+                for kw in gui_keywords
+            )
         except Exception:
             return False
 
@@ -1358,7 +1360,8 @@ class PyLoaderGenerator:
             # Prepare project tasks
             project_tasks = []
             for project_name, project in projects.items():
-                project_dir = self.root_dir / project_name
+                # Use the actual directory from toml_path instead of project name
+                project_dir = project.toml_path.parent
                 if not project_dir.is_dir():
                     logger.error(
                         f"Project directory not found: {project_dir}, skipping..."