pysfi 0.1.7__py3-none-any.whl → 0.1.11__py3-none-any.whl

sfi/pysourcepack/pysourcepack.py

@@ -0,0 +1,308 @@
+"""Source code packaging tool for projects defined in projects.json."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import shutil
+from pathlib import Path
+
+__version__ = "0.1.0"
+__all__ = [
+    "pack_project",
+]
+
+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 = {
+    "__pycache__",
+    "*.pyc",
+    "*.pyo",
+    ".pytest_cache",
+    ".benchmarks",
+    "tests",
+    ".git",
+    ".gitignore",
+    "dist",
+    "build",
+    "*.egg-info",
+    "node_modules",
+    ".idea",
+    "*.log",
+}
+
+# Default files to include in packaging
+DEFAULT_INCLUDE = {
+    "*.py",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+}
+
+
+def should_exclude(path: Path, exclude_patterns: set[str]) -> bool:
+    """Check if a path should be excluded based on patterns.
+
+    Args:
+        path: Path to check
+        exclude_patterns: Set of patterns to exclude
+
+    Returns:
+        True if path should be excluded, False otherwise
+    """
+    for pattern in exclude_patterns:
+        if pattern.startswith("*"):
+            # Wildcard pattern (e.g., "*.pyc")
+            if path.match(pattern):
+                return True
+        else:
+            # Exact name pattern
+            if path.name == pattern:
+                return True
+            if path.parts:
+                # Check if any parent directory matches
+                for part in path.parts:
+                    if part == pattern:
+                        return True
+    return False
+
+
+def should_include(
+    path: Path, include_patterns: set[str], exclude_patterns: set[str]
+) -> bool:
+    """Check if a path should be included based on include and exclude patterns.
+
+    Args:
+        path: Path to check
+        include_patterns: Set of patterns to include
+        exclude_patterns: Set of patterns to exclude
+
+    Returns:
+        True if path should be included, False otherwise
+    """
+    # Check if should be excluded first
+    if should_exclude(path, exclude_patterns):
+        return False
+
+    # If no include patterns, include everything not excluded
+    if not include_patterns:
+        return True
+
+    # Check if matches any include pattern
+    for pattern in include_patterns:
+        if pattern.startswith("*"):
+            # Wildcard pattern (e.g., "*.py")
+            if path.match(pattern):
+                return True
+        else:
+            # Exact name pattern
+            if path.name == pattern:
+                return True
+            if path.is_dir() and path.name == pattern:
+                # Include directory and all its contents
+                return True
+
+    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
+
+    if not project_path.is_dir():
+        logger.error(f"{project_path} is not a directory")
+        return False
+
+    return True
+
+
+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.
+
+    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)
+
+    Returns:
+        True if packing succeeded, False otherwise
+    """
+    logger.debug(f"Start packing project: {project_name}")
+
+    if project_name not in projects:
+        logger.error(f"Project '{project_name}' not found in projects.json")
+        return False
+
+    if not project_name:
+        logger.error("Project name cannot be empty")
+        return False
+
+    project_path = base_dir if len(projects) == 1 else base_dir / project_name
+    output_dir = base_dir / "dist" / "src" / project_name
+
+    logger.debug(f"Project path: {project_path}, project_name: {project_name}")
+    if not _check_project_path(project_path):
+        return False
+
+    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
+
+        logger.info(
+            f"Successfully packed {project_name}: {copied_files} files, {copied_dirs} directories"
+        )
+        return True
+
+    except Exception as e:
+        logger.error(f"Error packing project {project_name}: {e}")
+        return False
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and return an argument parser for the PySourcePack tool."""
+    parser = argparse.ArgumentParser(
+        description="PySourcePack - Source code packaging tool",
+        epilog="Pack source code and resources for projects defined in projects.json",
+    )
+    parser.add_argument(
+        "directory",
+        default=str(cwd),
+        nargs="?",
+        help="Base directory containing project folders (default: current directory)",
+    )
+    parser.add_argument(
+        "-p",
+        "--project",
+        default=None,
+        help="Project name to pack (default: pack all projects)",
+    )
+    parser.add_argument(
+        "-l",
+        "--list",
+        action="store_true",
+        help="List all available projects",
+    )
+    parser.add_argument(
+        "--include",
+        nargs="*",
+        default=None,
+        help="File patterns to include (default: *.py, README.md, pyproject.toml)",
+    )
+    parser.add_argument(
+        "--exclude",
+        nargs="*",
+        default=None,
+        help="File patterns to exclude (default: __pycache__, *.pyc, tests, .benchmarks, etc.)",
+    )
+    parser.add_argument(
+        "--debug",
+        "-d",
+        action="store_true",
+        help="Enable debug mode",
+    )
+    return parser
+
+
+def main() -> None:
+    from sfi.pyprojectparse.pyprojectparse import Solution
+
+    parser = create_parser()
+    args = parser.parse_args()
+
+    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
+
+    if not projects:
+        logger.error("No projects found in projects.json")
+        return
+
+    if args.list:
+        logger.info("Available projects:")
+        for info in projects.values():
+            logger.info(info)
+        return
+
+    # 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
+
+    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")