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

{pysfi-0.1.14.dist-info → pysfi-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysfi
-Version: 0.1.14
+Version: 0.1.15
 Summary: Single File commands for Interactive python.
 Requires-Python: >=3.8
 Requires-Dist: tomli>=2.4.0; python_version < '3.11'

{pysfi-0.1.14.dist-info → pysfi-0.1.15.dist-info}/RECORD

@@ -1,8 +1,8 @@
-sfi/__init__.py,sha256=eGpIupcAG_5RqNCm908TwzDk-31Rhdn0iM-5Y2OwmIM,685
+sfi/__init__.py,sha256=TVJQhNdT9_xTAmwbMdf5rw-JogSq0EdM2iR-igNIHLk,685
 sfi/cli.py,sha256=o-sFO6I3X3DMO2I_Gzc9LziWBdm2ruHXpjbraXGzZi0,933
 sfi/alarmclock/__init__.py,sha256=AUnUxITgFPYgSjn9ug2DEejrz5HDP56zZKYu-6JW1vY,72
 sfi/alarmclock/alarmclock.py,sha256=ixVkbg548smUivRsqyI3YSZ81BWIrKawnuezAp3BzyE,11635
-sfi/bumpversion/__init__.py,sha256=ExAxydqhwVCrA3YRid3JYult88HKsSTqYPt6996x0UU,122
+sfi/bumpversion/__init__.py,sha256=yAaQaGUKnwPERhTaS4XXANQc9AT31nseY2dKomRPRmU,122
 sfi/bumpversion/bumpversion.py,sha256=Uxj0S8ZGmIRhfCx2ziWkVe5gHv74r68UPkiYzZcAwxo,21288
 sfi/cleanbuild/__init__.py,sha256=_bXrBcQkHQTE2484-UMWAWz8kq-2Yjn9hleLcjF-pJg,98
 sfi/cleanbuild/cleanbuild.py,sha256=Ilk4zBE48y6tUC3C5qp1pXdQ6CF0NZlra4ZbdiU5s2k,5270
@@ -10,7 +10,7 @@ sfi/condasetup/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
 sfi/condasetup/condasetup.py,sha256=tuRzRi4NKmIfqN4Gq5w-VmY7BnleizPhAbYta8AzH4c,4976
 sfi/docdiff/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
 sfi/docdiff/docdiff.py,sha256=YR8e-gkbvjH0Bjt5fVVW0-8b7lbinQs6TRo4B5XgEjE,7783
-sfi/docscan/__init__.py,sha256=eXv_iPeT_xOxv5lv4-axJQV28IISYYTqb6IRy3QTmIU,121
+sfi/docscan/__init__.py,sha256=v7sLqtKfRfuxZ4bAKVvR5FBc_SX44W9MOBL_vmmAuss,121
 sfi/docscan/docscan.py,sha256=hXSOrfMikyg-Zsi_mpZvn31ea1J0un90ftwpRoXxNdA,42765
 sfi/docscan/docscan_gui.py,sha256=KoXVHOQjUwtkxh5tI4V6mLBMl9PAP3Hp7zydJ_lppoQ,52345
 sfi/docscan/lang/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -30,12 +30,14 @@ sfi/llmserver/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
 sfi/llmserver/llmserver.py,sha256=Fm4Go7wif4xMGomMFDsyJnYMafXsWemGkr-VfaeYa6w,13530
 sfi/makepython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/makepython/makepython.py,sha256=GrzQTJyyB2PXugJK3yLxP1V5I_bSymW0qfkeqZvxRPA,43154
+sfi/pdfcrypt/__init__.py,sha256=cKY_rosu4Qo0QvJF5d_vFgvMMcH14JH6uElOMRXo654,565
+sfi/pdfcrypt/pdfcrypt.py,sha256=s7LMABQt4gW8UabuwdKdy_hgmSa8ZDePFrtab3tEkEA,13236
 sfi/pdfsplit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/pdfsplit/pdfsplit.py,sha256=LOz7PuLlLBiXlFTjJej9G0UvJ03GZ9H-Gghy8ErvJzE,6576
 sfi/pyarchive/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
-sfi/pyarchive/pyarchive.py,sha256=OnPbIRA0C9JdeyNsVZ6rJg7ExItKyJz4jVw5W4c92DA,38293
+sfi/pyarchive/pyarchive.py,sha256=ne8FZh79_0ZtIWCG6Ddg9uUF6JxTvFsvfilOLl4wYmI,38280
 sfi/pyembedinstall/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pyembedinstall/pyembedinstall.py,sha256=LHnuvr63DXuntdS6a_7uQynOfarK-30WBUerSzawSHE,24171
+sfi/pyembedinstall/pyembedinstall.py,sha256=1XOTR6Mg2YtP_-t9jRjiNGSSTw5TklDO60XPc3I9TL0,24158
 sfi/pylibpack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/pylibpack/pylibpack.py,sha256=AJbMY4aHJq0YhyUXryBargNqCUTeSwaUuc3SiCcjcko,57685
 sfi/pylibpack/rules/numpy.json,sha256=ee4gA5NBudFi3MaJA-QlBKQwiQAUb-eluF8HNVkl7Vk,384
@@ -45,13 +47,13 @@ sfi/pylibpack/rules/pyside2.json,sha256=uSSteT-3wDohWwQ36Z5mSOaSbxrR4565In4uZj_e
 sfi/pylibpack/rules/scipy.json,sha256=vTSi3W5BGWcwMkaDnyD6Yg7ijZdicPEUMw4fnRTnNf4,468
 sfi/pylibpack/rules/shiboken2.json,sha256=9Pl3eslvergyjlyHNknkyN0oZlcH3049WULe5WjsmKM,515
 sfi/pyloadergen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pyloadergen/pyloadergen.py,sha256=VWJzc0opmMVthHE_RGbWeLe-DBaMn94gZo2yYLkf8cI,45696
+sfi/pyloadergen/pyloadergen.py,sha256=NiQGk4I5LMNvEaMc9aasXKHGNSg127AcUR5hmDPm6sQ,45801
 sfi/pypack/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pypack/pypack.py,sha256=vDT_lVkq0eHeFCCR3pwjZGnF0EyQZDesM6ze--Tl194,22894
+sfi/pypack/pypack.py,sha256=v2qdSGL4cANO28mbaJSGbThiyJG33djsTcVy9RlwDgc,23031
 sfi/pyprojectparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sfi/pyprojectparse/pyprojectparse.py,sha256=qBHj8l-_ONxD4VA5KvCfXdvS3fbjfOls9gRX83I0TDE,30641
+sfi/pyprojectparse/pyprojectparse.py,sha256=XPY1E3mW6qkvuAlGBK8fpTfPQJYkWpQFcYZTZ4IlROk,29784
 sfi/pysourcepack/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
-sfi/pysourcepack/pysourcepack.py,sha256=5_KrI2Y1TKKcoYfsFpTNXWguj6n8CKdca8lgoBCsL8k,12160
+sfi/pysourcepack/pysourcepack.py,sha256=HNhO0Ry3kAzZJ5-bXlxn81jrh_GdjKzWFOyz7SQhN1Q,12158
 sfi/quizbase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/quizbase/quizbase.py,sha256=3tPUuYexZ9TVsNPPO_Itmr5OvyHSgY5OSUZwPoQt9zg,30605
 sfi/quizbase/quizbase_gui.py,sha256=m_Lj3au1a8gEv5x7KOTjomiP1NpXHUgHSPE4lLv63hY,34733
@@ -62,7 +64,7 @@ sfi/taskkill/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/taskkill/taskkill.py,sha256=wM9g8sWJVTy4GxXe26rKdax2lIBI-uH9wP5wRenriH4,11606
 sfi/which/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sfi/which/which.py,sha256=2YbGgSiT1ySapKVV1ESoPf4P-JU8vvzmsZY39NiVr6k,2596
-pysfi-0.1.14.dist-info/METADATA,sha256=1fFxs9DSKrmVtp4oKAD5HWOQa9qV9hvxKSDyLNPTaKI,4198
-pysfi-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pysfi-0.1.14.dist-info/entry_points.txt,sha256=iPXOCvVm9O0_qaqFnlFFlwklWsK7K4LygikeAhnkf2I,1259
-pysfi-0.1.14.dist-info/RECORD,,
+pysfi-0.1.15.dist-info/METADATA,sha256=LyUkSywzxLXVtmVvhzMuSKMxEo5EApdoyHk6q3eFcA0,4198
+pysfi-0.1.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pysfi-0.1.15.dist-info/entry_points.txt,sha256=j0zUSQnJ1YpYEKTK0oEICBjIyOAVZOd5Ss2_k0id530,1297
+pysfi-0.1.15.dist-info/RECORD,,

{pysfi-0.1.14.dist-info → pysfi-0.1.15.dist-info}/entry_points.txt

@@ -14,6 +14,7 @@ llmqnt = sfi.llmquantize.llmquantize:main
 llmsvr = sfi.llmserver.llmserver:main
 makepython = sfi.makepython.makepython:main
 mkp = sfi.makepython.makepython:main
+pdfcrypt = sfi.pdfcrypt.pdfcrypt:main
 pdfsplit = sfi.pdfsplit.pdfsplit:main
 pyarchive = sfi.pyarchive.pyarchive:main
 pyembedinstall = sfi.pyembedinstall.pyembedinstall:main

sfi/__init__.py

@@ -16,5 +16,5 @@ or imported as a Python library.
 
 from __future__ import annotations
 
-__version__ = "0.1.14"
+__version__ = "0.1.15"
 __all__ = ["__version__"]

sfi/bumpversion/__init__.py

@@ -2,4 +2,4 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.14"
+__version__ = "0.1.15"

sfi/docscan/__init__.py

@@ -1,3 +1,3 @@
 """Document scanner module for scanning and extracting content from various document formats."""
 
-__version__ = "0.1.14"
+__version__ = "0.1.15"

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/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/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..."

sfi/pypack/pypack.py

@@ -229,6 +229,10 @@ class PackageWorkflow:
         """
         return self.solution.projects
 
+    @cached_property
+    def sorted_projects(self) -> dict[str, Project]:
+        return dict(sorted(self.projects.items()))
+
     @property
     def dist_dir(self) -> Path:
         """Get distribution directory path."""
@@ -403,7 +407,7 @@ class PackageWorkflow:
     def list_projects(self) -> None:
         """List all available projects."""
         logger.info(f"Listing projects in {self.root_dir}")
-        for project in self.projects.values():
+        for project in self.sorted_projects.values():
             logger.info(f"  - {project}")
 
     def _scan_executables(self) -> list[Path]:

sfi/pyprojectparse/pyprojectparse.py

@@ -457,7 +457,6 @@ class Solution:
 
     root_dir: Path
     projects: dict[str, Project]
-    update: bool = False
     start_time: float = field(default_factory=time.perf_counter)
     time_stamp: datetime.datetime = field(default_factory=datetime.datetime.now)
 
@@ -466,7 +465,6 @@ class Solution:
             f"<Solution(\n"
             f"  root_dir={self.root_dir!r},\n"
             f"  projects: {len(self.projects)},\n"
-            f"  update={self.update!r},\n"
             f"  time_used={self.elapsed_time:.4f}s,\n"
             f"  timestamp={self.time_stamp!r}\n"
             f")>"
@@ -570,9 +568,7 @@ class Solution:
         return None
 
     @classmethod
-    def from_toml_files(
-        cls, root_dir: Path, toml_files: list[Path], update: bool = False
-    ) -> Solution:
+    def from_toml_files(cls, root_dir: Path, toml_files: list[Path]) -> Solution:
         """Create a Solution instance by parsing multiple pyproject.toml files.
 
         Args:
@@ -620,12 +616,10 @@ class Solution:
 
             projects[project.name] = project
 
-        return cls(root_dir=root_dir, projects=projects, update=update)
+        return cls(root_dir=root_dir, projects=projects)
 
     @classmethod
-    def from_json_data(
-        cls, root_dir: Path, json_data: dict[str, Any], update: bool = False
-    ) -> Solution:
+    def from_json_data(cls, root_dir: Path, json_data: dict[str, Any]) -> Solution:
         """Create a Solution instance from JSON data.
 
         Args:
@@ -660,10 +654,10 @@ class Solution:
         except Exception as e:
             logger.error(f"Unknown error loading project data from JSON data: {e}")
 
-        return cls(root_dir=root_dir, projects=projects, update=update)
+        return cls(root_dir=root_dir, projects=projects)
 
     @classmethod
-    def from_json_file(cls, json_file: Path, update: bool = False) -> Solution:
+    def from_json_file(cls, json_file: Path) -> Solution:
         """Create a Solution instance from a JSON file.
 
         Args:
@@ -682,7 +676,7 @@ class Solution:
             with json_file.open("r", encoding="utf-8") as f:
                 loaded_data = json.load(f)
             logger.debug(f"\t - Loaded project data from {json_file}")
-            return cls.from_json_data(json_file.parent, loaded_data, update=update)
+            return cls.from_json_data(json_file.parent, loaded_data)
         except (OSError, json.JSONDecodeError, KeyError) as e:
             logger.error(f"Error loading project data from {json_file}: {e}")
             return cls(root_dir=json_file.parent, projects={})
@@ -691,7 +685,7 @@ class Solution:
             return cls(root_dir=json_file.parent, projects={})
 
     @classmethod
-    def from_directory(cls, root_dir: Path, update: bool = False) -> Solution:
+    def from_directory(cls, root_dir: Path) -> Solution:
         """Create a Solution instance by scanning a directory for pyproject.toml files.
 
         This method recursively searches the given directory for pyproject.toml files,
@@ -709,13 +703,9 @@ class Solution:
             logger.error(f"Error: {root_dir} is not a directory")
             return cls(root_dir=root_dir, projects={})
 
-        # Use walrus operator to avoid intermediate variable
-        if not update and (project_json := root_dir / "projects.json").is_file():
-            return cls.from_json_file(project_json, update=update)
-
         logger.debug(f"Parsing pyproject.toml in {root_dir}...")
         toml_files = list(root_dir.rglob("pyproject.toml"))
-        return cls.from_toml_files(root_dir, toml_files, update=update)
+        return cls.from_toml_files(root_dir, toml_files)
 
     def _write_project_json(self):
         """Write the project data to a projects.json file for caching.
@@ -729,12 +719,6 @@ class Solution:
         """
         # Cache json_file reference to avoid repeated cached_property access
         json_file = self.json_file
-        if json_file.exists() and not self.update:
-            logger.info(
-                f"\t - Skip write project data file {json_file}, already exists"
-            )
-            return
-
         try:
             # Pre-cache raw_data access to avoid repeated property access
             serializable_data = {
@@ -772,12 +756,6 @@ def create_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--debug", "-d", action="store_true", help="Enable debug logging output"
     )
-    parser.add_argument(
-        "--update",
-        "-u",
-        action="store_true",
-        help="Force update by re-parsing projects instead of using cache",
-    )
     return parser
 
 
@@ -794,4 +772,4 @@ def main() -> None:
     if args.debug:
         logger.setLevel(logging.DEBUG)
 
-    Solution.from_directory(Path(args.directory), update=args.update)
+    Solution.from_directory(Path(args.directory))

sfi/pysourcepack/pysourcepack.py

@@ -118,7 +118,6 @@ class ProjectPacker:
 
     parent: PySourcePacker
     project: Project
-    project_name: str
     include_patterns: set[str]
     exclude_patterns: set[str]
 
@@ -130,16 +129,13 @@ class ProjectPacker:
     @cached_property
     def project_path(self) -> Path:
         """Get project directory path."""
-        return (
-            self.parent.root_dir
-            if self.is_single_project
-            else self.parent.root_dir / self.project_name
-        )
+        # Use the actual directory from toml_path instead of project name
+        return self.project.toml_path.parent
 
     @cached_property
     def output_dir(self) -> Path:
         """Get output directory path."""
-        return self.parent.root_dir / "dist" / "src" / self.project_name
+        return self.parent.root_dir / "dist" / "src" / self.project.normalized_name
 
     def validate_project_path(self) -> bool:
         """Validate project path exists and is a directory."""
@@ -159,14 +155,14 @@ class ProjectPacker:
         Returns:
             True if packing succeeded, False otherwise
         """
-        logger.debug(f"Start packing project: {self.project_name}")
+        logger.debug(f"Start packing project: {self.project.normalized_name}")
 
-        if not self.project_name:
+        if not self.project.normalized_name:
             logger.error("Project name cannot be empty")
             return False
 
         logger.debug(
-            f"Project path: {self.project_path}, project_name: {self.project_name}"
+            f"Project path: {self.project_path}, project_name: {self.project.normalized_name}"
         )
         if not self.validate_project_path():
             return False
@@ -177,7 +173,9 @@ class ProjectPacker:
         copied_files = 0
         copied_dirs = 0
 
-        logger.info(f"Packing project '{self.project_name}' to {self.output_dir}")
+        logger.info(
+            f"Packing project '{self.project.normalized_name}' to {self.output_dir}"
+        )
 
         try:
             for item in self.project_path.iterdir():
@@ -202,12 +200,12 @@ class ProjectPacker:
                     copied_dirs += 1
 
             logger.info(
-                f"Successfully packed {self.project_name}: {copied_files} files, {copied_dirs} directories"
+                f"Successfully packed {self.project.normalized_name}: {copied_files} files, {copied_dirs} directories"
             )
             return True
 
         except Exception as e:
-            logger.error(f"Error packing project {self.project_name}: {e}")
+            logger.error(f"Error packing project {self.project.normalized_name}: {e}")
             return False
 
 
@@ -248,7 +246,6 @@ class PySourcePacker:
         packer = ProjectPacker(
             parent=self,
             project=project,
-            project_name=project_name,
             include_patterns=self.include_patterns,
             exclude_patterns=self.exclude_patterns,
         )