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

sfi/img2pdf/img2pdf.py

@@ -0,0 +1,453 @@
+"""Convert images in a directory to a single PDF file.
+
+This module provides functionality to convert multiple image files in a directory
+into a single PDF file. It supports various image formats and offers options
+to normalize images (scale, rotate) before conversion.
+
+Command: img2pdf [--normalize]
+"""
+
+from __future__ import annotations
+
+import argparse
+import atexit
+import concurrent.futures
+import json
+import logging
+from dataclasses import dataclass
+from functools import cached_property
+from pathlib import Path
+
+from PIL import Image
+from PIL.Image import Resampling
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+CONFIG_FILE = Path.home() / ".pysfi" / "img2pdf.json"
+
+
+@dataclass
+class ImageToPdfConfig:
+    """Configuration for image to PDF conversion."""
+
+    DPI: int = 300
+    EXTENSIONS: set[str] = None
+
+    def __post_init__(self) -> None:
+        # Initialize default extensions if not provided
+        if self.EXTENSIONS is None:
+            self.EXTENSIONS = {
+                ".jpg",
+                ".jpeg",
+                ".png",
+                ".gif",
+                ".bmp",
+                ".webp",
+                ".tiff",
+                ".ico",
+            }
+
+        # Load existing configuration from file
+        if CONFIG_FILE.exists():
+            try:
+                config_data = json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+                # Update configuration items, keeping defaults as fallback
+                for key, value in config_data.items():
+                    if hasattr(self, key) and isinstance(
+                        value, type(getattr(self, key))
+                    ):
+                        if key == "EXTENSIONS":
+                            setattr(self, key, set(value))
+                        else:
+                            setattr(self, key, value)
+            except (json.JSONDecodeError, TypeError, AttributeError):
+                print(f"Warning: Could not load config from {CONFIG_FILE}")
+
+    def save(self) -> None:
+        """Save current configuration to file."""
+        CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        config_dict = {"DPI": self.DPI, "EXTENSIONS": list(self.EXTENSIONS)}
+        CONFIG_FILE.write_text(json.dumps(config_dict, indent=4), encoding="utf-8")
+
+
+conf = ImageToPdfConfig()
+atexit.register(conf.save)
+
+
+# Magic numbers for image file headers.
+_MAGIC_NUMBERS: dict[str, bytes] = {
+    "jpg": b"\xff\xd8\xff",
+    "jpeg": b"\xff\xd8\xff",
+    "png": b"\x89PNG\r\n\x1a\n",
+    "gif": b"GIF87a",
+    "bmp": b"BM",
+    "webp": b"RIFFf\x00\x00\x00WEBP",
+    "tiff": b"II*\x00",
+    "ico": b"ICON",
+    "svg": b"<svg",
+}
+
+
+def is_valid_image(file_path: Path) -> bool:
+    """Validate image file.
+
+    Args:
+        file_path: Path to the image file to validate
+
+    Returns:
+        bool: True if the file is a valid image file, False otherwise
+    """
+    # Basic validation.
+    try:
+        stat_result = file_path.stat()
+        if stat_result.st_size == 0:
+            logger.debug(f"Empty file: {file_path}")
+            return False
+    except OSError:
+        logger.debug(f"File not found or inaccessible: {file_path}")
+        return False
+
+    # Extension validation.
+    ext = file_path.suffix.lower()
+    if ext not in conf.EXTENSIONS:
+        logger.debug(f"Invalid image extension: {ext}, {file_path}")
+        return False
+
+    # File header validation.
+    try:
+        with file_path.open("rb") as f:
+            header = f.read(16)  # Read more bytes to improve detection
+            if not any(header.startswith(v) for v in _MAGIC_NUMBERS.values()):
+                logger.debug(f"Invalid image header: {header[:8]}")
+                return False
+    except OSError:
+        logger.debug(f"Cannot read file header: {file_path}")
+        return False
+
+    logger.info(f"Valid image: {file_path}")
+    return True
+
+
+@dataclass(frozen=True)
+class ImageToPDFRunner:
+    """Image to PDF converter processor.
+
+    Processes image files in a directory and converts them to a single PDF file.
+    Supports normalization (scaling, rotating) of images before conversion.
+    """
+
+    root_dir: Path  # Directory containing images to convert
+    dpi: int  # DPI setting for PDF output
+    normalize: bool = True  # Whether to normalize images (scale, rotate)
+
+    def run(self) -> None:
+        """Execute the image to PDF conversion process.
+
+        Converts all valid images in the root directory to a single PDF file.
+        The resulting PDF is saved in the same directory with the directory name as filename.
+        """
+        logger.info(f"Start converting, using dpi={self.dpi}")
+        converted_images = self.converted_images
+        if not converted_images:
+            logger.error(f"No converted image file found in: {self.root_dir}")
+            return
+
+        # Save the PDF with optimized settings
+        converted_images[0].save(
+            self.output_pdf,
+            "PDF",
+            resolution=100.0,
+            save_all=True,
+            append_images=converted_images[1:],
+            optimize=True,
+        )
+        logger.info(f"Create pdf file: {self.output_pdf}")
+
+    @cached_property
+    def output_pdf(self) -> Path:
+        """Get the output PDF file path.
+
+        Returns:
+            Path object for the output PDF file, located in the root directory
+            with the directory name as the filename.
+        """
+        return self.root_dir / f"{self.root_dir.name}.pdf"
+
+    @cached_property
+    def size(self) -> tuple[int, int]:
+        """Get page size based on DPI setting.
+
+        Returns:
+            Tuple of (width, height) in pixels based on DPI
+        """
+        return (int(8.27 * self.dpi), int(11.69 * self.dpi))
+
+    @cached_property
+    def page_size(self) -> tuple[int, int]:
+        """Get page size based on DPI setting.
+
+        Returns:
+            Tuple of (width, height) in pixels based on DPI
+        """
+        return (int(8.27 * self.dpi), int(11.69 * self.dpi))
+
+    @cached_property
+    def converted_images(self) -> list[Image.Image]:
+        """Convert all image files to PIL Image objects.
+
+        Processes images in batches to manage memory usage and uses ThreadPoolExecutor
+        for parallel conversion within each batch.
+
+        Returns:
+            List of PIL Image objects representing converted images.
+        """
+        # Process images in batches to manage memory usage
+        batch_size = 10  # Adjust batch size based on available memory
+        all_results = []
+
+        for i in range(0, len(self.image_files), batch_size):
+            batch = self.image_files[i : i + batch_size]
+            logger.info(
+                f"Processing batch {i // batch_size + 1}/{(len(self.image_files) - 1) // batch_size + 1}"
+            )
+
+            # Use ThreadPoolExecutor to convert images in parallel within each batch
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=min(len(batch), 4)
+            ) as executor:
+                # Submit all conversion tasks for this batch
+                futures = [
+                    executor.submit(self._convert, file, normalize=self.normalize)
+                    for file in batch
+                ]
+
+                # Collect results, filtering out None values
+                batch_results = [
+                    future.result() for future in futures if future.result() is not None
+                ]
+
+                all_results.extend(batch_results)
+
+                # Explicitly clean up completed futures to free memory
+                for future in futures:
+                    del future
+
+        return all_results
+
+    @cached_property
+    def image_files(self) -> list[Path]:
+        """Get list of valid image files in the root directory.
+
+        Returns:
+            List of Path objects representing valid image files, sorted alphabetically.
+        """
+        all_files = list(self.root_dir.iterdir())
+        image_filepath = sorted([file for file in all_files if is_valid_image(file)])
+
+        if not image_filepath:
+            logger.warning(f"No valid image files found in: {self.root_dir}")
+            logger.info(f"Total files in directory: {len(all_files)}")
+            return []
+        else:
+            logger.info(
+                f"Found {len(image_filepath)} valid image files out of {len(all_files)} total files"
+            )
+
+        return image_filepath
+
+    def _convert(
+        self,
+        filepath: Path,
+        normalize: bool = True,
+    ) -> Image.Image | None:
+        """Convert image to PDF.
+
+        Args:
+            filepath: Path to the image file to convert
+            normalize: Whether to normalize the image (scale, rotate).
+                Defaults to True.
+
+        Returns:
+            PIL Image object if conversion successful, None otherwise.
+
+        Raises:
+            Exception: If there's an error opening the image
+        """
+        try:
+            # Open and convert to RGB immediately to reduce memory usage
+            with Image.open(str(filepath)) as img:
+                # Convert to RGB if needed to ensure compatibility with PDF
+                if img.mode in ("RGBA", "LA", "P"):
+                    # Handle transparency by compositing on white background
+                    rgb_img = Image.new("RGB", img.size, (255, 255, 255))
+                    if img.mode == "P" and "transparency" in img.info:
+                        img = img.convert("RGBA")
+                    if img.mode in ("RGBA", "LA"):
+                        rgb_img.paste(
+                            img,
+                            mask=img.split()[-1]
+                            if img.mode == "RGBA"
+                            else img.split()[-1],
+                        )
+                    else:
+                        rgb_img.paste(img)
+                    image = rgb_img
+                else:
+                    image = img.convert("RGB")
+        except Exception as e:
+            logger.error(f"Failed to open image {filepath}: {e}")
+            return None
+
+        if normalize:
+            logger.info(f"Normalizing image: {filepath}")
+
+            image = self._auto_rotate_image(image)
+            image = self._auto_scale_image(image)
+            image.thumbnail(self.page_size, Resampling.LANCZOS)
+
+            # Create new image with white background and paste the thumbnail
+            converted_image = Image.new(
+                "RGB",
+                self.page_size,
+                (255, 255, 255),
+            )
+            converted_image.paste(
+                image,
+                (
+                    (self.page_size[0] - image.size[0]) // 2,
+                    (self.page_size[1] - image.size[1]) // 2,
+                ),
+            )
+            logger.info(f"Image normalized: {filepath}")
+        else:
+            # Ensure image is in RGB mode
+            converted_image = image
+
+        if converted_image:
+            logger.debug(f"Convert image: {filepath} successfully")
+            # Return RGB converted image
+            return converted_image
+
+        logger.warning(f"Convert image: {filepath} failed")
+        # Ensure cleanup of any created image objects
+        try:
+            if "image" in locals():
+                del image
+            if "rgb_img" in locals():
+                del rgb_img
+        except:
+            pass  # Ignore cleanup errors
+        return None
+
+    def _auto_rotate_image(self, image: Image.Image) -> Image.Image:
+        """Auto rotate image to correct orientation.
+
+        If the image width is greater than its height, rotates the image 90 degrees
+        clockwise to convert from landscape to portrait orientation.
+
+        Args:
+            image: PIL Image object to rotate
+
+        Returns:
+            PIL Image object in portrait orientation
+        """
+        width, height = image.size
+        if width > height:
+            image = image.rotate(90, expand=True)
+
+        return image
+
+    def _auto_scale_image(self, image: Image.Image) -> Image.Image:
+        """Auto scale image to fit page dimensions.
+
+        If the image is smaller than the page size, scales it up proportionally
+        to fit within the page dimensions while maintaining aspect ratio.
+
+        Args:
+            image: PIL Image object to scale
+
+        Returns:
+            Scaled PIL Image object
+        """
+        if image.size[0] < self.page_size[0] or image.size[1] < self.page_size[1]:
+            scale_w = self.page_size[0] / image.size[0]
+            scale_h = self.page_size[1] / image.size[1]
+            scale = max(
+                scale_w,
+                scale_h,
+            )
+
+            new_size = (
+                int(image.size[0] * scale),
+                int(image.size[1] * scale),
+            )
+            image = image.resize(new_size, Resampling.LANCZOS)
+        return image
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command line arguments for the img2pdf tool.
+
+    Returns:
+        Namespace object containing parsed arguments:
+        - directory: Path to the directory containing images to convert
+        - dpi: DPI setting for the output PDF
+        - normalize: Whether to normalize images (scale, rotate)
+    """
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Convert images to PDF.")
+    parser.add_argument(
+        "directory",
+        type=str,
+        nargs="?",
+        default=str(Path.cwd()),
+        help="Image directory",
+    )
+    parser.add_argument("--dpi", type=int, default=300, help="DPI for PDF")
+    parser.add_argument(
+        "--normalize",
+        "-n",
+        action="store_true",
+        dest="normalize",
+        help="Normalize images (scale, rotate)",
+    )
+    parser.add_argument(
+        "--no-normalize",
+        action="store_false",
+        dest="normalize",
+        help="Disable image normalization",
+    )
+    args = parser.parse_args()
+
+    return args
+
+
+def main() -> None:
+    """Main entry point for the img2pdf command line tool.
+
+    Parses command line arguments, validates the input directory,
+    and executes the image to PDF conversion process.
+    """
+    args = parse_args()
+
+    # Convert string path to Path object
+    directory_path = Path(args.directory)
+
+    # Validate directory exists
+    if not directory_path.exists():
+        logger.error(f"Directory does not exist: {directory_path}")
+        return
+
+    if not directory_path.is_dir():
+        logger.error(f"Path is not a directory: {directory_path}")
+        return
+
+    proc = ImageToPDFRunner(
+        root_dir=directory_path,
+        dpi=args.dpi,
+        normalize=args.normalize,
+    )
+    proc.run()

sfi/llmclient/llmclient.py

@@ -11,8 +11,8 @@ import json
 import logging
 import sys
 from codecs import getincrementaldecoder
+from dataclasses import dataclass
 from pathlib import Path
-from types import SimpleNamespace
 from typing import ClassVar
 from urllib.error import URLError
 from urllib.request import Request, urlopen
@@ -34,14 +34,15 @@ from PySide2.QtWidgets import (
     QWidget,
 )
 
-CONFIG_FILE = Path.home() / ".sfi" / "llmclient.json"
+CONFIG_FILE = Path.home() / ".pysfi" / "llmclient.json"
 logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
 logger = logging.getLogger(__name__)
 
 CONNECTION_TIMEOUT = 5
 
 
-class LLMClientConfig(SimpleNamespace):
+@dataclass
+class LLMClientConfig:
     """LLM Chat client configuration."""
 
     TITLE: str = "Llama Local Model Tool"
@@ -52,18 +53,23 @@ class LLMClientConfig(SimpleNamespace):
     TEMPERATURE: float = 0.7
     TOP_P: float = 0.9
     TOP_K: int = 40
-
     MAX_TOKENS_RANGE: ClassVar[list[int]] = [1, 4096]
     TEMPERATURE_RANGE: ClassVar[list[float]] = [0.0, 2.0]
     TOP_P_RANGE: ClassVar[list[float]] = [0.0, 1.0]
     TOP_K_RANGE: ClassVar[list[int]] = [1, 100]
+    _loaded_from_file: bool = False
 
-    def __init__(self) -> None:
+    def __post_init__(self) -> None:
         if CONFIG_FILE.exists():
             logger.info("Loading configuration from %s", CONFIG_FILE)
             try:
-                self.__dict__.update(json.loads(CONFIG_FILE.read_text()))
-            except (json.JSONDecodeError, TypeError) as e:
+                config_data = json.loads(CONFIG_FILE.read_text())
+                # Update instance attributes with loaded values
+                for key, value in config_data.items():
+                    if hasattr(self, key):
+                        setattr(self, key, value)
+                self._loaded_from_file = True
+            except (json.JSONDecodeError, TypeError, AttributeError) as e:
                 logger.warning("Failed to load configuration: %s", e)
                 logger.info("Using default configuration")
         else:
@@ -72,7 +78,24 @@ class LLMClientConfig(SimpleNamespace):
     def save(self) -> None:
         """Save configuration."""
         CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
-        CONFIG_FILE.write_text(json.dumps(vars(self), indent=4))
+        # Convert dataclass to dict for JSON serialization
+        config_dict = {}
+        for attr_name in dir(self):
+            if not attr_name.startswith("_") and attr_name not in [
+                "WIN_SIZE",
+                "WIN_POS",
+                "MAX_TOKENS_RANGE",
+                "TEMPERATURE_RANGE",
+                "TOP_P_RANGE",
+                "TOP_K_RANGE",
+            ]:
+                try:
+                    attr_value = getattr(self, attr_name)
+                    if not callable(attr_value):
+                        config_dict[attr_name] = attr_value
+                except AttributeError:
+                    continue
+        CONFIG_FILE.write_text(json.dumps(config_dict, indent=4))
 
 
 conf = LLMClientConfig()

sfi/llmquantize/llmquantize.py

@@ -8,8 +8,8 @@ import logging
 import pathlib
 import subprocess
 import sys
+from dataclasses import dataclass
 from pathlib import Path
-from types import SimpleNamespace
 
 from PySide2.QtCore import QThread, Signal, Slot
 from PySide2.QtGui import QMoveEvent, QResizeEvent
@@ -29,28 +29,46 @@ from PySide2.QtWidgets import (
     QWidget,
 )
 
-CONFIG_FILE = Path.home() / ".sfi" / "llmquantize.json"
+CONFIG_FILE = Path.home() / ".pysfi" / "llmquantize.json"
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-class QuantizerConfig(SimpleNamespace):
+@dataclass
+class QuantizerConfig:
     """GGUF量化转换工具配置."""
 
     TITLE: str = "GGUF量化转换工具"
-    WIN_SIZE: list[int] = [600, 500]  # noqa: RUF012
-    WIN_POS: list[int] = [100, 100]  # noqa: RUF012
+    WIN_SIZE: list[int] = None
+    WIN_POS: list[int] = None
     LAST_INPUT_FILE: str = ""
-    SELECTED_QUANTS: list[str] = ["Q4_K_M", "Q5_K_M"]  # noqa: RUF012
+    SELECTED_QUANTS: list[str] = None
+    _loaded_from_file: bool = False
+
+    def __post_init__(self) -> None:
+        # 初始化默认值
+        if self.WIN_SIZE is None:
+            self.WIN_SIZE = [600, 500]
+        if self.WIN_POS is None:
+            self.WIN_POS = [100, 100]
+        if self.SELECTED_QUANTS is None:
+            self.SELECTED_QUANTS = ["Q4_K_M", "Q5_K_M"]
 
-    def __init__(self) -> None:
         if CONFIG_FILE.exists():
             logger.info("Loading configuration from %s", CONFIG_FILE)
             try:
-                # 直接更新，忽略无效字段
-                self.__dict__.update(json.loads(CONFIG_FILE.read_text()))
-            except (json.JSONDecodeError, TypeError) as e:
+                config_data = json.loads(CONFIG_FILE.read_text())
+                # 更新实例属性，只更新存在的属性
+                for key, value in config_data.items():
+                    if hasattr(self, key):
+                        if key in ["WIN_SIZE", "WIN_POS", "SELECTED_QUANTS"]:
+                            # 对于列表类型，需要特别处理
+                            setattr(self, key, value)
+                        else:
+                            setattr(self, key, value)
+                self._loaded_from_file = True
+            except (json.JSONDecodeError, TypeError, AttributeError) as e:
                 logger.warning("Failed to load configuration: %s", e)
                 logger.info("Using default configuration")
         else:
@@ -59,7 +77,17 @@ class QuantizerConfig(SimpleNamespace):
     def save(self) -> None:
         """保存配置."""
         CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
-        CONFIG_FILE.write_text(json.dumps(vars(self), indent=4))
+        # 将数据类转换为字典进行JSON序列化
+        config_dict = {}
+        for attr_name in dir(self):
+            if not attr_name.startswith("_") and attr_name not in ["TITLE"]:
+                try:
+                    attr_value = getattr(self, attr_name)
+                    if not callable(attr_value):
+                        config_dict[attr_name] = attr_value
+                except AttributeError:
+                    continue
+        CONFIG_FILE.write_text(json.dumps(config_dict, indent=4))
 
 
 conf = QuantizerConfig()

sfi/llmserver/__init__.py

@@ -0,0 +1 @@
+