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

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:
@@ -233,11 +230,15 @@ 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."""
         return self.config.dist_dir
 
-    @cached_property
+    @property
     def build_dir(self) -> Path:
         """Get build directory path."""
         return self.config.build_dir
@@ -246,16 +247,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 +269,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 +308,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 +331,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 +341,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 +349,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 +367,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 +399,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}")
+        for project in self.sorted_projects.values():
+            logger.info(f"  - {project}")
 
     def _scan_executables(self) -> list[Path]:
         """Scan dist directory for executable files.
@@ -420,11 +416,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 +436,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 +455,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 +470,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 +542,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 +588,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 +660,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 +673,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!")

sfi/pyprojectparse/pyprojectparse.py

@@ -23,7 +23,8 @@ import time
 from dataclasses import dataclass, field
 from functools import cached_property
 from pathlib import Path
-from typing import Any
+from re import Pattern
+from typing import Any, Final
 
 if sys.version_info >= (3, 11):
     import tomllib
@@ -39,12 +40,12 @@ cwd = Path.cwd()
 is_windows = platform.system() == "Windows"
 
 # Precompiled regex for dependency name extraction (optimization)
-_DEP_NAME_PATTERN = re.compile(r"^([a-zA-Z0-9._-]+)")
-_EXTRA_PATTERN = re.compile(r"\[([^\]]+)\]")
-_VERSION_PATTERN = re.compile(r"[<>=!~].*$")
+_DEP_NAME_PATTERN: Final[Pattern[str]] = re.compile(r"^([a-zA-Z0-9._-]+)")
+_EXTRA_PATTERN: Final[Pattern[str]] = re.compile(r"\[([^\]]+)\]")
+_VERSION_PATTERN: Final[Pattern[str]] = re.compile(r"[<>=!~].*$")
 
 # Qt-related keywords and dependencies for faster detection
-_QT_DEPENDENCIES: frozenset[str] = frozenset((
+_QT_DEPENDENCIES: Final[frozenset[str]] = frozenset((
     "Qt",
     "PySide",
     "PyQt",
@@ -57,10 +58,10 @@ _QT_DEPENDENCIES: frozenset[str] = frozenset((
 ))
 
 # GUI-related keywords for faster detection
-_GUI_KEYWORDS: frozenset[str] = frozenset(("gui", "desktop"))
+_GUI_KEYWORDS: Final[frozenset[str]] = frozenset(("gui", "desktop"))
 
 # Required attributes for project validation (module-level constant for performance)
-_REQUIRED_ATTRS: frozenset[str] = frozenset(("name", "version", "description"))
+_REQUIRED_ATTRS: Final[frozenset[str]] = frozenset(("name", "version", "description"))
 
 
 @dataclass(frozen=True)
@@ -456,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)
 
@@ -465,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")>"
@@ -569,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:
@@ -619,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:
@@ -659,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:
@@ -680,6 +675,8 @@ class Solution:
             logger.debug(f"Loading project data from {json_file}...")
             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)
         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={})
@@ -687,11 +684,8 @@ class Solution:
             logger.error(f"Unknown error loading project data from {json_file}: {e}")
             return cls(root_dir=json_file.parent, projects={})
 
-        logger.debug(f"\t - Loaded project data from {json_file}")
-        return cls.from_json_data(json_file.parent, loaded_data, update=update)
-
     @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 = {
@@ -746,14 +730,11 @@ class Solution:
 
             with json_file.open("w", encoding="utf-8") as f:
                 json.dump(serializable_data, f, indent=2, ensure_ascii=False)
+            logger.info(f"Output written to {json_file}")
         except (OSError, json.JSONDecodeError, KeyError) as e:
             logger.error(f"Error writing output to {json_file}: {e}")
-            return
         except Exception as e:
             logger.error(f"Unknown error writing output to {json_file}: {e}")
-            return
-        else:
-            logger.info(f"Output written to {json_file}")
 
 
 def create_parser() -> argparse.ArgumentParser:
@@ -775,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
 
 
@@ -797,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/__init__.py

@@ -1 +1 @@
- 
+