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

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/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/pypack/pypack.py

@@ -24,7 +24,7 @@ from dataclasses import dataclass, field
 from enum import Enum
 from functools import cached_property
 from pathlib import Path
-from typing import Any, Protocol
+from typing import Any, Callable, Protocol
 
 from sfi.pyprojectparse.pyprojectparse import Project, Solution
 
@@ -148,18 +148,18 @@ class WorkflowConfig:
 
     @cached_property
     def normalized_directory(self) -> Path:
-        """Get normalized directory path."""
+        """Get normalized and resolved directory path."""
         return self.directory.resolve()
 
     @cached_property
     def dist_dir(self) -> Path:
         """Get distribution directory path."""
-        return self.directory / "dist"
+        return self.normalized_directory / "dist"
 
     @cached_property
     def build_dir(self) -> Path:
         """Get build directory path."""
-        return self.directory / "build"
+        return self.normalized_directory / "build"
 
 
 # Strategy Pattern Implementation for Cleaning
@@ -169,11 +169,8 @@ class StandardCleaningStrategy:
     def should_clean(self, entry: Path) -> bool:
         """Determine if entry should be cleaned using standard rules."""
         # Special case: projects.json file should always be cleaned
-        if entry.is_file() and entry.name == "projects.json":
-            return True
-
-        if not entry.is_dir():
-            return False
+        if entry.is_file():
+            return entry.name == "projects.json"
 
         # Protected directories starting with dot
         if entry.name.startswith(".") and entry.name in PROTECTED_DIRS:
@@ -232,12 +229,12 @@ class PackageWorkflow:
         """
         return self.solution.projects
 
-    @cached_property
+    @property
     def dist_dir(self) -> Path:
         """Get distribution directory path."""
         return self.config.dist_dir
 
-    @cached_property
+    @property
     def build_dir(self) -> Path:
         """Get build directory path."""
         return self.config.build_dir
@@ -246,16 +243,21 @@ class PackageWorkflow:
         """Clean build artifacts and package files using strategy pattern."""
         logger.info("Cleaning build artifacts using strategy pattern...")
 
-        cleaned_dirs: list[str] = []
-        cleaned_files: list[str] = []
-        failed_operations: list[str] = []
-
         entries_to_clean = [
             entry
             for entry in self.root_dir.iterdir()
             if self.cleaning_strategy.should_clean(entry)
         ]
 
+        if not entries_to_clean:
+            logger.info("No build artifacts found to clean")
+            return
+
+        # Track cleaning results
+        cleaned_dirs: list[str] = []
+        cleaned_files: list[str] = []
+        failed_operations: list[str] = []
+
         for entry in entries_to_clean:
             success, message = self.cleaning_strategy.clean_entry(entry)
             if success:
@@ -263,39 +265,37 @@ class PackageWorkflow:
                     cleaned_dirs.append(str(entry))
                 else:
                     cleaned_files.append(str(entry))
-                logger.info(message)
+                logger.debug(message)
             else:
                 failed_operations.append(message)
                 logger.warning(message)
 
         # Summary logging
-        if not cleaned_dirs and not cleaned_files:
-            logger.info("No build artifacts found to clean")
-        else:
-            logger.info(
-                f"Cleaned {len(cleaned_dirs)} directories and {len(cleaned_files)} file(s)"
-            )
+        logger.info(
+            f"Cleaned {len(cleaned_dirs)} directories and {len(cleaned_files)} file(s)"
+        )
 
         if failed_operations:
             logger.error(f"Failed operations: {len(failed_operations)}")
 
-    async def _run_in_executor(self, func, *args) -> None:
-        """Run a synchronous function in thread pool executor.
+    async def _run_sync_task(self, name: str, setup_func: Callable[[], None]) -> None:
+        """Run a synchronous task in thread pool executor.
 
         Args:
-            func: Function to execute
-            *args: Arguments to pass to the function
+            name: Name of the task for logging
+            setup_func: Function that returns the task to execute
         """
+        logger.info(LOG_SEPARATOR)
+        logger.info(f"Packing {name}...")
+
         loop = asyncio.get_running_loop()
-        await loop.run_in_executor(None, func, *args)
+        await loop.run_in_executor(None, setup_func)
+        logger.info(f"{name.capitalize()} packed.")
 
     async def pack_embed_python(self) -> None:
         """Pack embed python."""
         from sfi.pyembedinstall.pyembedinstall import EmbedInstaller
 
-        logger.info(LOG_SEPARATOR)
-        logger.info("Packing embed python...")
-
         def _run():
             installer = EmbedInstaller(
                 root_dir=self.root_dir,
@@ -304,22 +304,17 @@ class PackageWorkflow:
             )
             installer.run()
 
-        await self._run_in_executor(_run)
-        logger.info("Embed python packed.")
+        await self._run_sync_task("embed python", _run)
 
     async def pack_loaders(self) -> None:
         """Pack loaders for all projects concurrently."""
         from sfi.pyloadergen.pyloadergen import PyLoaderGenerator
 
-        logger.info(LOG_SEPARATOR)
-        logger.info("Packing loaders...")
-
         def _run():
             generator = PyLoaderGenerator(root_dir=self.root_dir)
             generator.run()
 
-        await self._run_in_executor(_run)
-        logger.info("Loaders packed.")
+        await self._run_sync_task("loaders", _run)
 
     async def pack_libraries(self) -> None:
         """Pack libraries for all projects concurrently."""
@@ -332,7 +327,7 @@ class PackageWorkflow:
             )
             libpacker.run()
 
-        await self._run_in_executor(_run)
+        await self._run_sync_task("libraries", _run)
 
     async def pack_source(self) -> None:
         """Pack source code for all projects concurrently."""
@@ -342,7 +337,7 @@ class PackageWorkflow:
             source_packer = PySourcePacker(root_dir=self.root_dir)
             source_packer.run()
 
-        await self._run_in_executor(_run)
+        await self._run_sync_task("source code", _run)
 
     async def pack_archive(self, archive_format: str) -> None:
         """Create archive for all projects.
@@ -350,18 +345,14 @@ class PackageWorkflow:
         Args:
             archive_format: Archive format (zip, tar, gztar, bztar, xztar, 7z, nsis)
         """
-        from sfi.pyarchive.pyarchive import PyArchiver, PyArchiveConfig
-
-        logger.info(LOG_SEPARATOR)
-        logger.info(f"Creating {archive_format} archives...")
+        from sfi.pyarchive.pyarchive import PyArchiveConfig, PyArchiver
 
         def _run():
             config = PyArchiveConfig(verbose=self.config.debug)
             archiver = PyArchiver(root_dir=self.root_dir, config=config)
             archiver.archive_projects(format=archive_format)
 
-        await self._run_in_executor(_run)
-        logger.info("Archives created.")
+        await self._run_sync_task(f"{archive_format} archives", _run)
 
     async def build(self) -> dict[str, Any]:
         """Execute the packaging workflow with concurrent optimization.
@@ -372,14 +363,14 @@ class PackageWorkflow:
         3. Create archive (optional, if archive_type is set)
 
         Returns:
-            Dict with results and summary
+            Dict with results and summary including output_dir and metadata
 
         Raises:
             FileNotFoundError: If required directories don't exist
             RuntimeError: If any packaging step fails
         """
         logger.info("Starting packaging workflow execution")
-        t0 = time.perf_counter()
+        start_time = time.perf_counter()
 
         try:
             # Stage 1: Pack embed python (prerequisite for other tasks)
@@ -404,15 +395,16 @@ class PackageWorkflow:
             logger.error(f"Workflow execution failed: {e}")
             raise RuntimeError(f"Packaging workflow failed: {e}") from e
 
-        t1 = time.perf_counter()
+        elapsed = time.perf_counter() - start_time
         logger.info(LOG_SEPARATOR)
-        logger.info(f"Packaging workflow completed in {t1 - t0:.2f}s")
+        logger.info(f"Packaging workflow completed in {elapsed:.2f}s")
         return {"output_dir": str(self.dist_dir), "metadata": {}}
 
     def list_projects(self) -> None:
+        """List all available projects."""
         logger.info(f"Listing projects in {self.root_dir}")
         for project in self.projects.values():
-            logger.info(f"{project}")
+            logger.info(f"  - {project}")
 
     def _scan_executables(self) -> list[Path]:
         """Scan dist directory for executable files.
@@ -420,11 +412,10 @@ class PackageWorkflow:
         Returns:
             List of executable file paths found in dist directory.
         """
-        dist_dir = self.root_dir / "dist"
+        dist_dir = self.dist_dir
         if not dist_dir.exists():
             return []
-        pattern = "*.exe" if is_windows else "*"
-        return [f for f in dist_dir.glob(pattern) if f.is_file() and f.suffix == ext]
+        return [f for f in dist_dir.glob(f"*{ext}") if f.is_file()]
 
     def _resolve_executable(self, match_name: str | None) -> Path | None:
         """Resolve executable by scanning dist directory and matching name.
@@ -441,22 +432,18 @@ class PackageWorkflow:
 
         # Auto-select if only one executable and no name specified
         if not match_name:
-            if len(executables) == 1:
-                return executables[0]
-            return None
+            return executables[0] if len(executables) == 1 else None
 
-        # Exact match (without extension)
         lower_name = match_name.lower()
+
+        # Try exact match (without extension)
         for exe in executables:
             if exe.stem.lower() == lower_name:
                 return exe
 
-        # Fuzzy match (case-insensitive substring)
+        # Try fuzzy match (case-insensitive substring)
         matches = [exe for exe in executables if lower_name in exe.stem.lower()]
-        if len(matches) == 1:
-            return matches[0]
-
-        return None
+        return matches[0] if len(matches) == 1 else None
 
     def list_executables(self) -> None:
         """List all executables in dist directory."""
@@ -464,9 +451,9 @@ class PackageWorkflow:
         if not executables:
             logger.info("No executables found in dist directory")
             return
-        logger.info(f"Available executables in {self.root_dir / 'dist'}:")
+        logger.info(f"Available executables in {self.dist_dir}:")
         for exe in executables:
-            logger.info(f"  {exe.stem}")
+            logger.info(f"  - {exe.stem}")
 
     def run_project(
         self, match_name: str | None, project_args: list[str] | None = None
@@ -479,41 +466,66 @@ class PackageWorkflow:
         """
         exe_path = self._resolve_executable(match_name)
 
-        if not exe_path and not match_name:
-            executables = self._scan_executables()
+        # Handle executable not found cases
+        if not exe_path:
+            self._handle_executable_not_found(match_name)
+            return
+
+        # Build and execute command
+        cmd = self._build_executable_command(exe_path, project_args)
+
+        try:
+            subprocess.run(cmd, check=True, cwd=self.root_dir)
+            logger.info(f"{exe_path.stem} ran successfully")
+        except subprocess.CalledProcessError as e:
+            logger.error(f"{exe_path.stem} failed with exit code {e.returncode}")
+        except FileNotFoundError:
+            logger.error(f"Executable not found: {exe_path}")
+        except Exception as e:
+            logger.error(f"Failed to run {exe_path}: {e}")
+
+    def _handle_executable_not_found(self, match_name: str | None) -> None:
+        """Handle cases where executable cannot be found.
+
+        Args:
+            match_name: Executable name that was being searched for
+        """
+        executables = self._scan_executables()
+
+        if not match_name:
             if len(executables) == 0:
                 logger.error("No executables found in dist directory")
-                return
             elif len(executables) > 1:
                 logger.error(
                     "Multiple executables found. Please specify which one to run:"
                 )
                 self.list_executables()
-                return
-            logger.error("Unable to auto-select executable")
-            self.list_executables()
-            return
-        elif not exe_path:
+            else:
+                logger.error("Unable to auto-select executable")
+        else:
             logger.error(f"Executable '{match_name}' not found")
+
+        if len(executables) > 0:
             self.list_executables()
-            return
 
-        logger.info(f"Running {exe_path.stem} in {self.root_dir}")
+    def _build_executable_command(
+        self, exe_path: Path, project_args: list[str] | None
+    ) -> list[str]:
+        """Build command list for executable execution.
+
+        Args:
+            exe_path: Path to executable
+            project_args: Additional arguments to pass
+
+        Returns:
+            List of command arguments
+        """
         cmd = [str(exe_path.resolve())]
-        logger.info(f"Command: {cmd}")
         if project_args:
             cmd.extend(project_args)
             logger.info(f"Arguments: {' '.join(project_args)}")
-
-        try:
-            subprocess.run(cmd, check=True)
-            logger.info(f"{exe_path.stem} ran successfully")
-        except subprocess.CalledProcessError as e:
-            logger.error(f"{exe_path.stem} failed with exit code {e.returncode}")
-        except FileNotFoundError:
-            logger.error(f"Executable not found: {exe_path}")
-        except Exception as e:
-            logger.error(f"Failed to run {exe_path}: {e}")
+        logger.info(f"Running: {' '.join(cmd)}")
+        return cmd
 
 
 def parse_args() -> argparse.Namespace:
@@ -526,34 +538,44 @@ def parse_args() -> argparse.Namespace:
         prog="pypack", description="Python packaging tool with workflow orchestration"
     )
 
+    # Add common arguments to parent parser
+    parent_parser = argparse.ArgumentParser(add_help=False)
+    parent_parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
+
     # Create subparsers
     subparsers = parser.add_subparsers(
         dest="command", required=True, help="Available commands"
     )
 
     # Version subcommand
-    version_parser = subparsers.add_parser(
-        "version", aliases=["v"], help="Show version information"
+    subparsers.add_parser(
+        "version",
+        aliases=["v"],
+        help="Show version information",
+        parents=[parent_parser],
     )
-    version_parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
 
     # List subcommand
-    list_parser = subparsers.add_parser(
-        "list", aliases=["l", "ls"], help="List available projects"
+    subparsers.add_parser(
+        "list",
+        aliases=["l", "ls"],
+        help="List available projects",
+        parents=[parent_parser],
     )
-    list_parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
 
     # Clean subcommand
-    clean_parser = subparsers.add_parser(
-        "clean", aliases=["c"], help="Clean build artifacts"
+    subparsers.add_parser(
+        "clean", aliases=["c"], help="Clean build artifacts", parents=[parent_parser]
     )
-    clean_parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
 
     # Run subcommand
-    run_parser = subparsers.add_parser("run", aliases=["r"], help="Run a project")
+    run_parser = subparsers.add_parser(
+        "run", aliases=["r"], help="Run a project", parents=[parent_parser]
+    )
     run_parser.add_argument(
         "project",
         type=str,
+        nargs="?",
         help="Project or executable name (e.g., 'docscan' or 'docscan-gui')",
     )
     run_parser.add_argument(
@@ -562,13 +584,11 @@ def parse_args() -> argparse.Namespace:
         nargs="*",
         help="Additional arguments to pass to the project",
     )
-    run_parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
 
     # Build subcommand
     build_parser = subparsers.add_parser(
-        "build", aliases=["b"], help="Build project packages"
+        "build", aliases=["b"], help="Build project packages", parents=[parent_parser]
     )
-    build_parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
     build_parser.add_argument(
         "--python-version", type=str, default="3.8.10", help="Python version to install"
     )
@@ -636,6 +656,7 @@ def main() -> None:
     """Main entry point for package workflow tool using factory pattern."""
     args = parse_args()
 
+    # Configure logging level
     if args.debug:
         logging.getLogger().setLevel(logging.DEBUG)
 
@@ -648,17 +669,18 @@ def main() -> None:
         cleaning_strategy=StandardCleaningStrategy(),
     )
 
-    # Handle different subcommands
-    if args.command in ("version", "v"):
+    # Command dispatch using pattern matching
+    command = args.command
+
+    if command in ("version", "v"):
         logger.info(f"pypack {__version__} (build {__build__})")
-        return
-    elif args.command in ("list", "l", "ls"):
+    elif command in ("list", "l", "ls"):
         workflow.list_projects()
-    elif args.command in ("run", "r"):
+    elif command in ("run", "r"):
         workflow.run_project(args.project, args.args)
-    elif args.command in ("clean", "c"):
+    elif command in ("clean", "c"):
         workflow.clean_project()
-    elif args.command in ("build", "b"):
+    elif command in ("build", "b"):
         try:
             asyncio.run(workflow.build())
             logger.info("Packaging completed successfully!")