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

sfi/pysourcepack/pysourcepack.py

@@ -5,19 +5,23 @@ from __future__ import annotations
 import argparse
 import logging
 import shutil
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from functools import cached_property
 from pathlib import Path
+from typing import Final
+
+from sfi.pyprojectparse.pyprojectparse import Project, Solution
 
 __version__ = "0.1.0"
-__all__ = [
-    "pack_project",
-]
+__all__ = ["PySourcePacker"]
 
 cwd = Path.cwd()
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 logger = logging.getLogger(__name__)
 
 # Default directories and files to exclude during packaging
-DEFAULT_EXCLUDE = {
+DEFAULT_EXCLUDE: Final = {
     "__pycache__",
     "*.pyc",
     "*.pyo",
@@ -35,7 +39,7 @@ DEFAULT_EXCLUDE = {
 }
 
 # Default files to include in packaging
-DEFAULT_INCLUDE = {
+DEFAULT_INCLUDE: Final = {
     "*.py",
     "README.md",
     "LICENSE",
@@ -108,98 +112,205 @@ def should_include(
     return False
 
 
-def _check_project_path(project_path: Path) -> bool:
-    if not project_path.exists():
-        logger.error(f"Project directory {project_path} does not exist")
-        return False
+@dataclass
+class ProjectPacker:
+    """Helper class to pack individual projects."""
+
+    parent: PySourcePacker
+    project: Project
+    project_name: str
+    include_patterns: set[str]
+    exclude_patterns: set[str]
+
+    @cached_property
+    def is_single_project(self) -> bool:
+        """Check if the project is the only one in the solution."""
+        return len(self.parent.solution.projects) == 1
+
+    @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
+        )
 
-    if not project_path.is_dir():
-        logger.error(f"{project_path} is not a directory")
-        return False
+    @cached_property
+    def output_dir(self) -> Path:
+        """Get output directory path."""
+        return self.parent.root_dir / "dist" / "src" / self.project_name
 
-    return True
+    def validate_project_path(self) -> bool:
+        """Validate project path exists and is a directory."""
+        if not self.project_path.exists():
+            logger.error(f"Project directory {self.project_path} does not exist")
+            return False
 
+        if not self.project_path.is_dir():
+            logger.error(f"{self.project_path} is not a directory")
+            return False
 
-def pack_project(
-    base_dir: Path,
-    projects: dict,
-    project_name: str,
-    include_patterns: set[str] | None = None,
-    exclude_patterns: set[str] | None = None,
-) -> bool:
-    """Pack project source code and resources to dist/src directory.
+        return True
 
-    Args:
-        base_dir: Base directory containing project folders
-        project_name: Name of the project to pack
-        include_patterns: File patterns to include (default: DEFAULT_INCLUDE)
-        exclude_patterns: File patterns to exclude (default: DEFAULT_EXCLUDE)
+    def pack(self) -> bool:
+        """Pack project source code and resources to dist/src directory.
 
-    Returns:
-        True if packing succeeded, False otherwise
-    """
-    logger.debug(f"Start packing project: {project_name}")
+        Returns:
+            True if packing succeeded, False otherwise
+        """
+        logger.debug(f"Start packing project: {self.project_name}")
 
-    if project_name not in projects:
-        logger.error(f"Project '{project_name}' not found in projects.json")
-        return False
+        if not self.project_name:
+            logger.error("Project name cannot be empty")
+            return False
 
-    if not project_name:
-        logger.error("Project name cannot be empty")
-        return False
+        logger.debug(
+            f"Project path: {self.project_path}, project_name: {self.project_name}"
+        )
+        if not self.validate_project_path():
+            return False
+
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Copy files
+        copied_files = 0
+        copied_dirs = 0
+
+        logger.info(f"Packing project '{self.project_name}' to {self.output_dir}")
+
+        try:
+            for item in self.project_path.iterdir():
+                if item.is_file():
+                    # For files, check if should be included
+                    if should_include(
+                        item, self.include_patterns, self.exclude_patterns
+                    ):
+                        dest_file = self.output_dir / item.name
+                        shutil.copy2(item, dest_file)
+                        logger.debug(f"Copied file: {item.name}")
+                        copied_files += 1
+                elif item.is_dir() and not should_exclude(item, self.exclude_patterns):
+                    # Copy directory recursively with exclude patterns
+                    dest_dir = self.output_dir / item.name
+                    if dest_dir.exists():
+                        shutil.rmtree(dest_dir)
+                    shutil.copytree(
+                        item, dest_dir, ignore=shutil.ignore_patterns(*DEFAULT_EXCLUDE)
+                    )
+                    logger.debug(f"Copied directory: {item.name}")
+                    copied_dirs += 1
+
+            logger.info(
+                f"Successfully packed {self.project_name}: {copied_files} files, {copied_dirs} directories"
+            )
+            return True
+
+        except Exception as e:
+            logger.error(f"Error packing project {self.project_name}: {e}")
+            return False
+
+
+@dataclass
+class PySourcePacker:
+    """Main class for packing Python source code."""
+
+    root_dir: Path
+    include_patterns: set[str] = field(default_factory=lambda: DEFAULT_INCLUDE)
+    exclude_patterns: set[str] = field(default_factory=lambda: DEFAULT_EXCLUDE)
+
+    @cached_property
+    def solution(self) -> Solution:
+        """Get the solution from the target directory."""
+        return Solution.from_directory(self.root_dir)
+
+    @cached_property
+    def projects(self) -> dict[str, Project]:
+        """Get the projects from the solution."""
+        return self.solution.projects
+
+    def pack_project(self, project_name: str) -> bool:
+        """Pack a single project.
+
+        Args:
+            project_name: Name of the project to pack
+
+        Returns:
+            True if packing succeeded, False otherwise
+        """
+        projects = self.solution.projects
+
+        if project_name not in projects:
+            logger.error(f"Project '{project_name}' not found in projects.json")
+            return False
+
+        project = projects[project_name]
+        packer = ProjectPacker(
+            parent=self,
+            project=project,
+            project_name=project_name,
+            include_patterns=self.include_patterns,
+            exclude_patterns=self.exclude_patterns,
+        )
 
-    project_path = base_dir if len(projects) == 1 else base_dir / project_name
-    output_dir = base_dir / "dist" / "src" / project_name
+        return packer.pack()
 
-    logger.debug(f"Project path: {project_path}, project_name: {project_name}")
-    if not _check_project_path(project_path):
-        return False
+    def run(self, project_name: str | None = None) -> None:
+        """Pack specified project or all projects concurrently.
+
+        Args:
+            project_name: Name of the project to pack, or None to pack all projects
+        """
 
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Use default patterns if not specified
-    if include_patterns is None:
-        include_patterns = DEFAULT_INCLUDE
-    if exclude_patterns is None:
-        exclude_patterns = DEFAULT_EXCLUDE
-
-    # Copy files
-    copied_files = 0
-    copied_dirs = 0
-
-    logger.info(f"Packing project '{project_name}' to {output_dir}")
-
-    try:
-        for item in project_path.iterdir():
-            if item.is_file():
-                # For files, check if should be included
-                if should_include(item, include_patterns, exclude_patterns):
-                    dest_file = output_dir / item.name
-                    shutil.copy2(item, dest_file)
-                    logger.debug(f"Copied file: {item.name}")
-                    copied_files += 1
-            elif item.is_dir() and not should_exclude(item, exclude_patterns):
-                # Copy directory recursively with exclude patterns
-                dest_dir = output_dir / item.name
-                if dest_dir.exists():
-                    shutil.rmtree(dest_dir)
-                shutil.copytree(
-                    item, dest_dir, ignore=shutil.ignore_patterns(*DEFAULT_EXCLUDE)
-                )
-                logger.debug(f"Copied directory: {item.name}")
-                copied_dirs += 1
+        if not self.projects:
+            logger.error("No projects found in projects.json")
+            return
+
+        # Pack specific project
+        if project_name:
+            if self.pack_project(project_name):
+                logger.info(f"Packed project '{project_name}' successfully")
+            else:
+                logger.error(f"Failed to pack project '{project_name}'")
+            return
+
+        # Pack all projects
+        logger.info(f"Start packing, projects: {self.projects}")
+
+        if len(self.projects) == 1:
+            # Single project: process directly
+            name = next(iter(self.projects))
+            success_count = 1 if self.pack_project(name) else 0
+        else:
+            # Multiple projects: process concurrently
+            logger.info(f"Packing {len(self.projects)} projects concurrently...")
+            success_count = 0
+
+            with ThreadPoolExecutor(max_workers=None) as executor:
+                future_to_name = {
+                    executor.submit(self.pack_project, name): name
+                    for name in self.projects
+                }
+
+                for future in as_completed(future_to_name):
+                    name = future_to_name[future]
+                    try:
+                        if future.result():
+                            success_count += 1
+                    except Exception as e:
+                        logger.error(f"Project {name} packing failed: {e}")
 
         logger.info(
-            f"Successfully packed {project_name}: {copied_files} files, {copied_dirs} directories"
+            f"Packed {success_count}/{len(self.projects)} projects successfully"
         )
-        return True
 
-    except Exception as e:
-        logger.error(f"Error packing project {project_name}: {e}")
-        return False
+    def list_projects(self) -> None:
+        """List all available projects."""
+        for name, project in self.projects.items():
+            logger.info(f"{name}: {project}")
 
 
-def create_parser() -> argparse.ArgumentParser:
+def parse_args() -> argparse.Namespace:
     """Create and return an argument parser for the PySourcePack tool."""
     parser = argparse.ArgumentParser(
         description="PySourcePack - Source code packaging tool",
@@ -241,68 +352,36 @@ def create_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="Enable debug mode",
     )
-    return parser
+    return parser.parse_args()
 
 
 def main() -> None:
-    from sfi.pyprojectparse.pyprojectparse import Solution
+    """Main entry point for pysourcepack."""
+    args = parse_args()
 
-    parser = create_parser()
-    args = parser.parse_args()
+    root_dir = Path(args.directory)
+    if not root_dir.exists():
+        logger.error(f"Root directory {root_dir} does not exist")
+        return
 
     if args.debug:
         logger.setLevel(logging.DEBUG)
 
-    # Load projects file
-    base_dir = Path(args.directory)
-    project_json = base_dir / "projects.json"
-    projects = Solution.from_directory(base_dir, recursive=True, update=True).projects
-
-    if not project_json.exists():
-        logger.error("Failed to create projects.json")
-        return
+    # Create packer instance
+    include_patterns = set(args.include) if args.include else DEFAULT_INCLUDE
+    exclude_patterns = set(args.exclude) if args.exclude else DEFAULT_EXCLUDE
 
-    if not projects:
-        logger.error("No projects found in projects.json")
-        return
+    packer = PySourcePacker(
+        root_dir=root_dir,
+        include_patterns=include_patterns,
+        exclude_patterns=exclude_patterns,
+    )
 
     if args.list:
-        logger.info("Available projects:")
-        for info in projects.values():
-            logger.info(info)
-        return
+        packer.list_projects()
 
-    # Process include and exclude patterns
-    include_patterns = set(args.include) if args.include else None
-    exclude_patterns = set(args.exclude) if args.exclude else None
+    packer.run(project_name=args.project)
 
-    logger.debug(
-        f"Start packing, config: base_dir={base_dir}, project_name={args.project}, include_patterns={include_patterns}, exclude_patterns={exclude_patterns}"
-    )
-    # Pack specified project or all projects
-    if args.project:
-        if pack_project(
-            base_dir=base_dir,
-            projects=projects,
-            project_name=args.project,
-            include_patterns=include_patterns,
-            exclude_patterns=exclude_patterns,
-        ):
-            logger.info(f"Packed project '{args.project}' successfully")
-        else:
-            logger.error(f"Failed to pack project '{args.project}'")
-        return
 
-    # Pack all projects
-    logger.info("Packing all projects...")
-    success_count = 0
-    for project_name in projects:
-        if pack_project(
-            base_dir=base_dir,
-            projects=projects,
-            project_name=project_name,
-            include_patterns=include_patterns,
-            exclude_patterns=exclude_patterns,
-        ):
-            success_count += 1
-    logger.info(f"Packed {success_count}/{len(projects)} projects successfully")
+if __name__ == "__main__":
+    main()

sfi/quizbase/quizbase_gui.py

@@ -85,7 +85,7 @@ plugin_path = str(qt_dir / "plugins" / "platforms")
 os.environ["QT_QPA_PLATFORM_PLUGIN_PATH"] = plugin_path
 
 
-_WRONG_ANSWERS_FILE = Path.home() / ".sfi" / "wrong_answers.json"
+_WRONG_ANSWERS_FILE = Path.home() / ".pysfi" / "wrong_answers.json"
 
 
 @dataclass
@@ -119,7 +119,7 @@ class ConfigManager:
     def __init__(self, config_file: Path | None = None):
         """Initialize configuration manager."""
         if config_file is None:
-            config_dir = Path.home() / ".sfi"
+            config_dir = Path.home() / ".pysfi"
             config_dir.mkdir(exist_ok=True)
             config_file = config_dir / "quizbase_gui.json"
         self.config_file = config_file