spl-core 7.6.1__tar.gz → 7.8.0__tar.gz

{spl_core-7.6.1 → spl_core-7.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: spl-core
-Version: 7.6.1
+Version: 7.8.0
 Summary: Software Product Line Support for CMake
 License: MIT
 Author: Avengineers
@@ -23,6 +23,8 @@ Requires-Dist: kconfiglib (>=14.1,<15.0)
 Requires-Dist: mlx-traceability (>=10.0,<11.0)
 Requires-Dist: myst-parser (>=0.16)
 Requires-Dist: py-app-dev (>=2.1,<3.0)
+Requires-Dist: pypeline-runner (>=1,<=2)
+Requires-Dist: pypeline-semantic-release (>=0.4.1,<=0.5.0)
 Requires-Dist: sphinx (>=7.3,<8.0)
 Requires-Dist: sphinx-book-theme (>=1.1,<2.0)
 Requires-Dist: sphinx-copybutton (>=0.5,<0.6)

{spl_core-7.6.1 → spl_core-7.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "spl-core"
-version = "7.6.1"
+version = "7.8.0"
 description = "Software Product Line Support for CMake"
 authors = ["Avengineers <karsten.guenther@kamg.de>"]
 license = "MIT"
@@ -46,6 +46,8 @@ myst-parser = ">=0.16"
 mlx-traceability = "^10.0"
 sphinx-book-theme = "^1.1"
 sphinx-design = ">=0.5,<0.7"
+pypeline-semantic-release = ">=0.4.1,<=0.5.0"
+pypeline-runner = ">=1,<=2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = ">=7,<9"
@@ -59,7 +61,6 @@ mashumaro = "*"
 loguru = "*"
 flake8 = "*"
 pipenv = "*"
-pypeline-runner = "^1.3"
 python-semantic-release = "^9.16.1"
 
 [tool.semantic_release]

spl_core-7.8.0/src/spl_core/__init__.py

@@ -0,0 +1 @@
+__version__ = "7.8.0"

spl_core-7.8.0/src/spl_core/steps/collect_pr_changes.py

@@ -0,0 +1,97 @@
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional
+
+from mashumaro.mixins.json import DataClassJSONMixin
+from py_app_dev.core.logging import logger
+from py_app_dev.core.subprocess import SubprocessExecutor
+from pypeline.domain.pipeline import PipelineStep
+from pypeline_semantic_release.steps import CIContext
+
+
+@dataclass
+class PR_Changes(DataClassJSONMixin):
+    """Dataclass for storing PR changes."""
+
+    ci_system: str
+    target_branch: str
+    current_branch: str
+    commit_id: str
+    changed_files: List[str]
+
+
+class CollectPRChanges(PipelineStep):
+    """Collect changed files from a pull request."""
+
+    def run(self) -> None:
+        logger.info(f"{self.get_name()}")
+        ci_contexts = self.execution_context.data_registry.find_data(CIContext)
+        if len(ci_contexts) > 0:
+            ci_context = ci_contexts[0]
+            logger.info(f"CI context: {ci_context}")
+            if ci_context.is_pull_request:
+                logger.info(f"Collecting PR changes between branch {ci_context.target_branch} and {ci_context.current_branch}")
+                changed_files = self._get_changed_files(ci_context.target_branch, ci_context.current_branch)
+                output_file = self.get_outputs()[0]
+                output_file.parent.mkdir(parents=True, exist_ok=True)
+                output_file.write_text(json.dumps(
+                    PR_Changes(
+                        ci_system=ci_context.ci_system.name, target_branch=ci_context.target_branch, current_branch=ci_context.current_branch, commit_id=self._get_commit_id(ci_context), changed_files=changed_files
+                    ).to_dict(),
+                    indent=2
+                ))
+                logger.info(f"PR changes saved to {output_file}")
+
+    def _get_changed_files(self, target_branch: str, current_branch: str) -> List[str]:
+        """Get list of changed files in the current branch/PR"""
+        try:
+            result = SubprocessExecutor(["git", "fetch", "origin", current_branch]).execute(handle_errors=False)
+            if result and result.returncode == 0:
+                result = SubprocessExecutor(["git", "diff", "--name-only", f"origin/{target_branch}...origin/{current_branch}"]).execute(handle_errors=False)
+
+                if result and result.returncode == 0 and result.stdout.strip():
+                    files = [line.strip() for line in result.stdout.strip().split("\n") if line.strip()]
+                    return files
+
+        except Exception as e:
+            logger.error(f"Git command failed: {e}")
+            return []  # Ensure a list is always returned
+        return []
+
+    def get_inputs(self) -> List[Path]:
+        return []
+
+    def get_outputs(self) -> List[Path]:
+        return [self.output_dir.joinpath("pr_changes.json")]
+
+    def get_name(self) -> str:
+        return self.__class__.__name__
+
+    def update_execution_context(self) -> None:
+        pass
+
+    def get_config(self) -> dict[str, str] | None:
+        """
+        Get runnable configuration.
+
+        (!) Do NOT put sensitive information in the configuration. It will be stored in a file.
+        """
+        return {"latest_commit": self._get_commit_id()}
+
+    def _get_commit_id(self, ci_context: Optional[CIContext] = None) -> str:
+        """Get the latest commit ID in the current branch."""
+        try:
+            if not ci_context:
+                ci_contexts = self.execution_context.data_registry.find_data(CIContext)
+                if len(ci_contexts) == 0:
+                    logger.info("No CI context found.")
+                    return ""
+                ci_context = ci_contexts[0]
+            if isinstance(ci_context, CIContext) and ci_context.is_pull_request:
+                result = SubprocessExecutor(["git", "rev-parse", f"origin/{ci_context.current_branch}"]).execute(handle_errors=False)
+                if result and result.returncode == 0:
+                    return result.stdout.strip()
+        except Exception as e:
+            logger.info(f"Failed to get commit ID: {e}")
+        return ""

{spl_core-7.6.1 → spl_core-7.8.0}/src/spl_core/test_utils/spl_build.py

@@ -6,8 +6,7 @@ from pathlib import Path
 from typing import Callable, ClassVar, List, Optional
 
 from py_app_dev.core.logging import time_it
-
-from spl_core.common.command_line_executor import CommandLineExecutor
+from py_app_dev.core.subprocess import SubprocessExecutor
 
 
 @dataclass
@@ -110,7 +109,7 @@ class SplBuild:
             target = self.target if self.target else "all"
         return_code = -1
         while True:
-            cmd = [
+            cmd: list[str | Path] = [
                 "build.bat",
                 "-build",
                 "-buildKit",
@@ -125,7 +124,11 @@ class SplBuild:
                 cmd.extend(["-buildType", self.build_type])
             if additional_args:
                 cmd.extend(additional_args)
-            result = CommandLineExecutor().execute(cmd)
+            # Cast to Union[str, List[Union[str, Path]]] to satisfy SubprocessExecutor type
+            result = SubprocessExecutor(command=cmd).execute(handle_errors=False)
+            if result is None:
+                return_code = -1
+                break
             return_code = result.returncode
             if result.returncode:
                 if result.stdout:

spl_core-7.6.1/src/spl_core/__init__.py

@@ -1 +0,0 @@
-__version__ = "7.6.1"

spl_core-7.6.1/src/spl_core/common/command_line_executor.py

@@ -1,70 +0,0 @@
-import locale
-import subprocess
-from pathlib import Path
-from typing import Dict, List, Optional
-
-
-class CommandLineExecutor:
-    def __init__(
-        self,
-        cwd: Optional[Path] = None,
-        env: Optional[Dict[str, str]] = None,
-    ):
-        """
-        A class for executing command line commands.
-
-        Args:
-        - cmd: A string or list of strings representing the command to be executed.
-        - cwd: An optional Path object representing the current working directory.
-        - env: An optional dictionary of environment variables to be used in the command execution.
-        """
-        self.current_working_directory = cwd
-        self.env = env
-
-    def execute(self, cmd: str | List[str]) -> subprocess.CompletedProcess[str]:
-        """
-        Executes the command and returns a CompletedProcess object.
-
-        Returns:
-        - A subprocess.CompletedProcess object representing the result of the command execution.
-        """
-        if isinstance(cmd, str):
-            command: str | list[str] = cmd
-            use_shell = True
-        else:
-            # Check if any argument contains quotes, which indicates shell processing is needed
-            has_quotes = any('"' in arg or "'" in arg for arg in cmd)
-            if has_quotes:
-                command = " ".join(cmd)
-                use_shell = True
-            else:
-                command = cmd
-                use_shell = False
-
-        output = ""
-        try:
-            print("=" * 120)
-            print(f"= Running command: {command}")
-            print("=" * 120)
-            with subprocess.Popen(
-                command,
-                cwd=str(self.current_working_directory or Path.cwd()),
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                bufsize=1,
-                text=True,
-                env=self.env,
-                universal_newlines=True,
-                encoding=locale.getpreferredencoding(False),
-                errors="replace",
-                shell=use_shell,
-            ) as process:
-                if process.stdout:
-                    for line in process.stdout:
-                        print(line, end="")
-                        # We have to store the stdout content.
-                        # This is necessary because the stdout object is closed after we printed its content
-                        output += line
-        except Exception:
-            raise RuntimeError(f"Command '{command}' failed.")  # noqa: B904
-        return subprocess.CompletedProcess(args=command, returncode=process.returncode, stdout=output, stderr=None)