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

sfi/pyarchive/pyarchive.py

@@ -0,0 +1,418 @@
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any
+
+from sfi.pyprojectparse.pyprojectparse import Project, Solution
+
+logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+logger = logging.getLogger(__name__)
+
+ARCHIVE_FORMATS: frozenset[str] = frozenset(["zip", "7z", "nsis"])
+
+DEFAULT_IGNORE_PATTERNS: frozenset[str] = frozenset([
+    "__pycache__",
+    "*.pyc",
+    "*.pyo",
+    ".git",
+    ".gitignore",
+    ".pytest_cache",
+    ".coverage",
+    "*.egg-info",
+    "dist",
+    "build",
+    "*.log",
+    ".DS_Store",
+    "Thumbs.db",
+    ".ruff_cache",
+    ".benchmarks",
+])
+
+
+def should_ignore(file_path: Path, ignore_patterns: set[str]) -> bool:
+    """Check if a file should be ignored based on patterns."""
+    from fnmatch import fnmatch
+
+    # Convert to string for pattern matching
+    file_str = str(file_path)
+
+    for pattern in ignore_patterns:
+        if pattern.startswith("*."):
+            # Check just the filename
+            if fnmatch(file_path.name, pattern):
+                return True
+        else:
+            # Check full path
+            if pattern in file_str or fnmatch(file_str, pattern):
+                return True
+
+    return False
+
+
+def load_projects(config_file: Path) -> dict[str, Any]:
+    """Load projects configuration from JSON file."""
+    if not config_file.exists():
+        logger.error(f"Configuration file not found: {config_file}")
+        return {}
+
+    with open(config_file, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def get_project_directory(project_name: str, base_dir: Path) -> Path | None:
+    """Locate the project directory."""
+    project_path = base_dir / project_name
+    if project_path.exists() and project_path.is_dir():
+        return project_path
+
+    return None
+
+
+def check_command_available(command: str) -> bool:
+    """Check if a command is available in the system PATH."""
+    try:
+        subprocess.run(
+            ["where", command] if shutil.which("where") else ["which", command],
+            capture_output=True,
+            check=True,
+            shell=True,
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+
+def archive_zip(
+    dist_dir: Path,
+    output_file: Path,
+    ignore_patterns: set[str],
+) -> bool:
+    """Create ZIP archive using Python's zipfile module."""
+    try:
+        import zipfile
+
+        logger.info(f"Creating ZIP archive: {output_file}, using files: {dist_dir}")
+        with zipfile.ZipFile(output_file, "w", zipfile.ZIP_DEFLATED) as zipf:
+            for file_path in dist_dir.rglob("*"):
+                if file_path.is_file() and not should_ignore(
+                    file_path, ignore_patterns
+                ):
+                    arcname = file_path.relative_to(dist_dir)
+                    zipf.write(file_path, arcname)
+                    logger.debug(f"Added: {arcname}")
+
+        logger.info(f"ZIP archive created successfully: {output_file}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to create ZIP archive: {e}")
+        return False
+
+
+def archive_7z(
+    dist_dir: Path,
+    output_file: Path,
+    ignore_patterns: set[str],
+) -> bool:
+    """Create 7z archive using 7z command."""
+    if not check_command_available("7z"):
+        logger.error("7z command not found. Please install 7-Zip.")
+        return False
+
+    try:
+        logger.info(f"Creating 7z archive: {output_file}")
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Create temp directory with filtered files
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir) / dist_dir.name
+            shutil.copytree(
+                dist_dir, temp_path, ignore=shutil.ignore_patterns(*ignore_patterns)
+            )
+
+            cmd = ["7z", "a", "-t7z", str(output_file), str(temp_path / "*")]
+            subprocess.run(cmd, check=True, shell=True)
+
+        logger.info(f"7z archive created successfully: {output_file}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to create 7z archive: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error creating 7z archive: {e}")
+        return False
+
+
+def create_nsis_script(
+    project: Project,
+    dist_dir: Path,
+    output_file: Path,
+) -> Path | None:
+    """Generate NSIS script file."""
+    # Convert source_dir to use forward slashes for NSIS compatibility
+    source_dir_str = str(dist_dir).replace("\\", "/")
+
+    nsis_script = f"""
+!include "MUI2.nsh"
+
+Name "{project.name}"
+OutFile "{output_file.name}"
+InstallDir "$PROGRAMFILES\\{project.name}"
+InstallDirRegKey HKCU "Software\\{project.name}" ""
+RequestExecutionLevel admin
+VIProductVersion {project.version.replace(".", ",")}.0
+VIAddVersionKey "ProductName" "{project.name}"
+VIAddVersionKey "ProductVersion" "{project.version}"
+VIAddVersionKey "FileDescription" "{project.description}"
+VIAddVersionKey "FileVersion" "{project.version}"
+
+!define MUI_ABORTWARNING
+!insertmacro MUI_PAGE_WELCOME
+!insertmacro MUI_PAGE_LICENSE "LICENSE"
+!insertmacro MUI_PAGE_COMPONENTS
+!insertmacro MUI_PAGE_DIRECTORY
+!insertmacro MUI_PAGE_INSTFILES
+!insertmacro MUI_PAGE_FINISH
+
+!insertmacro MUI_UNPAGE_WELCOME
+!insertmacro MUI_UNPAGE_CONFIRM
+!insertmacro MUI_UNPAGE_INSTFILES
+!insertmacro MUI_UNPAGE_FINISH
+
+!insertmacro MUI_LANGUAGE "English"
+
+Section "{project.name} (required)" SecMain
+    SectionIn RO
+    SetOutPath "$INSTDIR"
+    File /r "{source_dir_str}\\*.*"
+SectionEnd
+
+Section "Start Menu Shortcuts"
+    CreateDirectory "$SMPROGRAMS\\{project.name}"
+    CreateShortcut "$SMPROGRAMS\\{project.name}\\{project.name}.lnk" "$INSTDIR\\main.py"
+SectionEnd
+
+Section "Uninstall"
+    Delete "$SMPROGRAMS\\{project.name}\\*.*"
+    RMDir "$SMPROGRAMS\\{project.name}"
+    RMDir /r "$INSTDIR"
+    DeleteRegKey /ifempty HKCU "Software\\{project.name}"
+SectionEnd
+"""
+
+    script_file = output_file.parent / f"{project.name}_installer.nsi"
+    try:
+        with open(script_file, "w", encoding="utf-8") as f:
+            f.write(nsis_script)
+        logger.info(f"NSIS script generated: {script_file}")
+        return script_file
+    except Exception as e:
+        logger.error(f"Failed to generate NSIS script: {e}")
+        return None
+
+
+def archive_nsis(
+    project: Project,
+    dist_dir: Path,
+    output_file: Path,
+    ignore_patterns: set[str],
+) -> bool:
+    """Create NSIS installer using makensis command."""
+    if not check_command_available("makensis"):
+        logger.error("makensis command not found. Please install NSIS.")
+        return False
+
+    try:
+        logger.info(f"Creating NSIS installer: {output_file}")
+        output_file.parent.mkdir(parents=True, exist_ok=True)
+
+        # Create temp directory with filtered files
+        import tempfile
+
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir) / dist_dir.name
+            shutil.copytree(
+                dist_dir, temp_path, ignore=shutil.ignore_patterns(*ignore_patterns)
+            )
+
+            script_file = create_nsis_script(
+                project=project,
+                dist_dir=temp_path,
+                output_file=output_file,
+            )
+            if not script_file or not script_file.exists():
+                return False
+
+            cmd = ["makensis", str(script_file)]
+            subprocess.run(cmd, check=True, shell=True)
+
+        logger.info(f"NSIS installer created successfully: {output_file}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to create NSIS installer: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error creating NSIS installer: {e}")
+        return False
+
+
+def archive_project(
+    project: Project,
+    directory: Path,
+    format: str,
+    ignore_patterns: set[str],
+) -> bool:
+    """Archive a single project."""
+    logger.info(f"Processing project: {project.name}")
+
+    dist_dir = directory / "dist"
+    if not dist_dir:
+        logger.warning(
+            f"Project dist directory not found: {project.name}, please build project first"
+        )
+        return False
+
+    output_dir = directory / "build"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    if format == "nsis":
+        output_file = output_dir / f"{project.name}-{project.version}-setup.exe"
+        return archive_nsis(
+            project=project,
+            dist_dir=dist_dir,
+            output_file=output_file,
+            ignore_patterns=ignore_patterns,
+        )
+    else:
+        extension = "zip" if format == "zip" else "7z"
+        output_file = output_dir / f"{project.name}-{project.version}.{extension}"
+
+        if format == "zip":
+            return archive_zip(
+                dist_dir=dist_dir,
+                output_file=output_file,
+                ignore_patterns=ignore_patterns,
+            )
+        elif format == "7z":
+            return archive_7z(
+                dist_dir=dist_dir,
+                output_file=output_file,
+                ignore_patterns=ignore_patterns,
+            )
+
+    logger.error(f"Unsupported format: {format}")
+    return False
+
+
+def archive_projects(
+    directory: Path,
+    format: str,
+    projects_to_archive: list | None = None,
+    ignore_patterns: set | None = None,
+) -> None:
+    """Archive all projects in the directory."""
+    if format not in ARCHIVE_FORMATS:
+        logger.error(
+            f"Unsupported format: {format}. Supported formats: {', '.join(ARCHIVE_FORMATS)}"
+        )
+        return
+    else:
+        logger.debug(f"Archiving projects in {directory} to `{format}` format")
+
+    ignore_patterns = (
+        ignore_patterns | DEFAULT_IGNORE_PATTERNS
+        if ignore_patterns
+        else set(DEFAULT_IGNORE_PATTERNS)
+    )
+    logger.debug(f"Ignoring patterns: {', '.join(ignore_patterns)}")
+
+    project_config = Solution.from_directory(root_dir=directory)
+    projects = project_config.projects
+
+    if not projects:
+        logger.error("No projects found in configuration")
+        return
+    else:
+        logger.debug(f"Found {len(projects)} projects")
+
+    projects_to_archive = projects_to_archive or list(projects.keys())
+    if not projects_to_archive:
+        logger.error("No projects to archive")
+        return
+    else:
+        logger.debug(f"Archiving projects: {', '.join(projects_to_archive)}")
+
+    success_count = 0
+    total_count = 0
+    for project_name in projects_to_archive:
+        if project_name not in projects:
+            logger.warning(f"Project not found: {project_name}")
+            continue
+        project = projects[project_name]
+        total_count += 1
+        if archive_project(
+            project=project,
+            directory=directory,
+            format=format,
+            ignore_patterns=ignore_patterns,
+        ):
+            success_count += 1
+
+    if success_count:
+        logger.info(
+            f"Archiving complete: {success_count}/{total_count} projects successfully archived"
+        )
+    else:
+        logger.error("Archiving failed")
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create parser for command line arguments."""
+    parser = argparse.ArgumentParser(description="Archive projects in directory")
+    parser.add_argument(
+        "directory",
+        type=Path,
+        nargs="?",
+        default=Path.cwd(),
+        help="Directory to archive for projects.",
+    )
+    parser.add_argument("--debug", "-d", action="store_true", help="Debug mode")
+    parser.add_argument(
+        "--format",
+        "-f",
+        type=str,
+        default="zip",
+        choices=ARCHIVE_FORMATS,
+        help=f"Archive format ({', '.join(ARCHIVE_FORMATS)})",
+    )
+    parser.add_argument(
+        "--project",
+        "-p",
+        type=str,
+        nargs="*",
+        help="Specific project(s) to archive (default: all projects)",
+    )
+    parser.add_argument(
+        "--ignore", type=str, nargs="*", help="Additional ignore patterns"
+    )
+    return parser
+
+
+def main():
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if args.debug:
+        logger.setLevel(logging.DEBUG)
+
+    archive_projects(
+        directory=args.directory,
+        format=args.format,
+        projects_to_archive=args.project,
+        ignore_patterns=set(args.ignore or []),
+    )