sflkit 0.5.6__tar.gz → 0.5.7__tar.gz

{sflkit-0.5.6/src/sflkit.egg-info → sflkit-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.6
+Version: 0.5.7
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/smythi93/sflkit/

{sflkit-0.5.6 → sflkit-0.5.7}/src/sflkit/__init__.py

@@ -5,7 +5,7 @@ from sflkit.analysis.analyzer import Analyzer
 from sflkit.config import Config, parse_config
 from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
-__version__ = "0.5.6"
+__version__ = "0.5.7"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.6 → sflkit-0.5.7}/src/sflkit/runners/run.py

@@ -25,6 +25,8 @@ PYTEST_RESULT_PATTERN = re.compile(
 
 DEFAULT_TIMEOUT = 10
 
+DEFAULT_MAX_WORKERS = 64
+
 
 class TestResult(enum.Enum):
     PASSING = "PASSING"
@@ -57,7 +59,7 @@ class Runner(abc.ABC):
         self.thread_support = thread_support
 
     @staticmethod
-    def use_parallel() -> "Runner":
+    def use_parallel() -> type["Runner"]:
         raise NotImplementedError()
 
     def get_tests(
@@ -66,24 +68,26 @@ class Runner(abc.ABC):
         files: Optional[List[os.PathLike] | os.PathLike] = None,
         base: Optional[os.PathLike] = None,
         environ: Environment = None,
+        python="python3",
         k: str = None,
     ) -> List[str]:
         return []
 
     def run_test(
-        self, directory: Path, test: str, environ: Environment = None
+        self, directory: Path, test: str, environ: Environment = None, python="python3"
     ) -> TestResult:
         return TestResult.UNDEFINED
 
     def filter_tests(self, tests: List[str]) -> List[str]:
+        # noinspection PyTypeChecker
         return list(filter(self.re_filter.search, tests))
 
     @staticmethod
     def safe(s: str):
-        s = s.encode("ascii", "ignore")
+        s: bytes = s.encode("ascii", "ignore")
         if len(s) > 255:
             return hashlib.md5(s).hexdigest()
-        s = s.decode("ascii")
+        s: str = s.decode("ascii")
         for c in string.punctuation:
             if c in s:
                 s = s.replace(c, "_")
@@ -95,12 +99,13 @@ class Runner(abc.ABC):
         output: Path,
         tests: List[str],
         environ: Environment = None,
+        python="python3",
     ):
         output.mkdir(parents=True, exist_ok=True)
         for test_result in TestResult:
             (output / test_result.get_dir()).mkdir(parents=True, exist_ok=True)
         for event_file, test in enumerate(tests):
-            test_result = self.run_test(directory, test, environ=environ)
+            test_result = self.run_test(directory, test, environ=environ, python=python)
             self.tests[test_result].add(test)
             if os.path.exists(directory / "EVENTS_PATH"):
                 shutil.move(
@@ -119,6 +124,7 @@ class Runner(abc.ABC):
         files: Optional[List[os.PathLike] | os.PathLike] = None,
         base: Optional[os.PathLike] = None,
         environ: Environment = None,
+        python="python3",
         k: str = None,
     ):
         self.passing_tests.clear()
@@ -131,15 +137,23 @@ class Runner(abc.ABC):
             directory,
             output,
             self.filter_tests(
-                self.get_tests(directory, files=files, base=base, environ=environ, k=k)
+                self.get_tests(
+                    directory,
+                    files=files,
+                    base=base,
+                    environ=environ,
+                    python=python,
+                    k=k,
+                )
             ),
             environ=environ,
+            python=python,
         )
 
 
 class VoidRunner(Runner):
     @staticmethod
-    def use_parallel() -> Runner:
+    def use_parallel() -> type[Runner]:
         return VoidRunner
 
 
@@ -290,11 +304,11 @@ class PytestRunner(Runner):
         self.set_python_path = set_python_path
 
     @staticmethod
-    def use_parallel() -> Runner:
+    def use_parallel() -> type[Runner]:
         return ParallelPytestRunner
 
     @staticmethod
-    def common_base(directory: Path, tests: List[str]) -> Path:
+    def common_base(directory: Path, tests: List[str]) -> Path | None:
         parts = directory.parts
         common_bases = {Path(*parts[:i]) for i in range(1, len(parts) + 1)}
         leaves_paths = {Path(r.split("::", 1)[0] if "::" in r else r) for r in tests}
@@ -323,7 +337,7 @@ class PytestRunner(Runner):
         return None
 
     @staticmethod
-    def get_files(files: List[os.PathLike]) -> Set[str]:
+    def get_files(files: List[str | os.PathLike[str]]) -> Set[str]:
         paths = set()
         for f in files:
             f = str(f)
@@ -393,6 +407,7 @@ class PytestRunner(Runner):
         files: Optional[List[os.PathLike] | os.PathLike] = None,
         base: Optional[os.PathLike] = None,
         environ: Environment = None,
+        python="python3",
         k: str = None,
     ) -> List[str]:
         c = []
@@ -416,7 +431,7 @@ class PytestRunner(Runner):
             c += str_files
         process = subprocess.run(
             [
-                "python3",
+                python,
                 "-m",
                 "pytest",
                 "--collect-only",
@@ -451,11 +466,11 @@ class PytestRunner(Runner):
         return False, None, None
 
     def run_test(
-        self, directory: Path, test: str, environ: Environment = None
+        self, directory: Path, test: str, environ: Environment = None, python="python3"
     ) -> TestResult:
         try:
             output = subprocess.run(
-                ["python3", "-m", "pytest", test],
+                [python, "-m", "pytest", test],
                 stdout=subprocess.PIPE,
                 env=environ,
                 cwd=directory,
@@ -464,7 +479,7 @@ class PytestRunner(Runner):
         except subprocess.TimeoutExpired:
             return TestResult.UNDEFINED
         successful, passing, failing = self.__get_pytest_result__(output)
-        if successful:
+        if successful and passing is not None and failing is not None:
             if passing > 0 and failing == 0:
                 return TestResult.PASSING
             elif failing > 0 and passing == 0:
@@ -496,7 +511,7 @@ class InputRunner(Runner):
         self.failing: Dict[str, List[str]] = self._prepare_tests(failing, "failing")
 
     @staticmethod
-    def use_parallel() -> Runner:
+    def use_parallel() -> type[Runner]:
         return ParallelInputRunner
 
     @staticmethod
@@ -529,22 +544,27 @@ class InputRunner(Runner):
         files: Optional[List[os.PathLike] | os.PathLike] = None,
         base: Optional[os.PathLike] = None,
         environ: Environment = None,
+        python="python3",
         k: str = None,
     ) -> List[str]:
         return list(self.passing.keys()) + list(self.failing.keys())
 
     def run_test(
-        self, directory: Path, test_name: str, environ: Environment = None
+        self,
+        directory: Path | None,
+        test: str,
+        environ: Environment = None,
+        python="python3",
     ) -> TestResult:
-        if "passing" in test_name:
-            test = self.passing[test_name]
+        if "passing" in test:
+            test_args = self.passing[test]
             result = TestResult.PASSING
         else:
-            test = self.failing[test_name]
+            test_args = self.failing[test]
             result = TestResult.FAILING
         try:
             subprocess.run(
-                ["python3", self.access] + test,
+                [python, self.access] + test_args,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 env=environ,
@@ -568,21 +588,27 @@ class ParallelPytestRunner(PytestRunner):
         super().__init__(
             re_filter, timeout, set_python_path, thread_support=thread_support
         )
-        self.workers = max(min(workers, os.cpu_count() or float("inf")), 1)
+        self.workers = max(min(workers, os.cpu_count() or DEFAULT_MAX_WORKERS), 1)
         self.is_parallel = True
         self.environ = None
+        self.python = None
         self.directory = None
         self.output = None
 
     @staticmethod
-    def use_parallel() -> Runner:
+    def use_parallel() -> type[Runner]:
         return ParallelPytestRunner
 
-    def process_test(self, test: str):
+    def process_test(
+        self,
+        test: str,
+    ):
         local_environ = self.environ.copy()
         events_path_name = f"EVENTS_PATH_{os.getpid()}"
         local_environ["EVENTS_PATH"] = events_path_name
-        tr = self.run_test(self.directory, test, environ=local_environ)
+        tr = self.run_test(
+            self.directory, test, environ=local_environ, python=self.python
+        )
         self.tests[tr].add(test)
         if os.path.exists(self.directory / events_path_name):
             shutil.move(
@@ -598,6 +624,7 @@ class ParallelPytestRunner(PytestRunner):
         output: Path,
         tests: List[str],
         environ: Environment = None,
+        python="python3",
     ):
         output.mkdir(parents=True, exist_ok=True)
         for test_result in TestResult:
@@ -605,7 +632,9 @@ class ParallelPytestRunner(PytestRunner):
 
         self.directory = directory
         self.output = output
+        # noinspection PyUnresolvedReferences
         self.environ = environ or os.environ.copy()
+        self.python = python
 
         with ProcessPoolExecutor(max_workers=self.workers) as executor:
             # Consume the iterator to ensure all tasks complete
@@ -625,23 +654,28 @@ class ParallelInputRunner(InputRunner):
         thread_support: bool = False,
     ):
         super().__init__(access, passing, failing, thread_support=thread_support)
-        self.workers = max(min(workers, os.cpu_count() or float("inf")), 1)
+        self.workers = max(min(workers, os.cpu_count() or DEFAULT_MAX_WORKERS), 1)
         self.is_parallel = True
         self.environ = None
-        self.directory: Path = None
-        self.output: Path = None
+        self.python = None
+        self.directory: Path | None = None
+        self.output: Path | None = None
 
     @staticmethod
-    def use_parallel() -> Runner:
+    def use_parallel() -> type[Runner]:
         return ParallelInputRunner
 
     def process_test(self, test_name: str):
         local_environ = self.environ.copy()
         events_path_name = f"EVENTS_PATH_{os.getpid()}"
         local_environ["EVENTS_PATH"] = events_path_name
-        tr = self.run_test(self.directory, test_name, environ=local_environ)
+        tr = self.run_test(
+            self.directory, test_name, environ=local_environ, python=self.python
+        )
         self.tests[tr].add(test_name)
+        # noinspection PyUnresolvedReferences
         if os.path.exists(self.directory / events_path_name):
+            # noinspection PyUnresolvedReferences
             shutil.move(
                 self.directory / events_path_name,
                 self.output / tr.get_dir() / self.safe(test_name),
@@ -655,6 +689,7 @@ class ParallelInputRunner(InputRunner):
         output: Path,
         tests: List[str],
         environ: Environment = None,
+        python="python3",
     ):
         output.mkdir(parents=True, exist_ok=True)
         for test_result in TestResult:
@@ -662,7 +697,9 @@ class ParallelInputRunner(InputRunner):
 
         self.directory = directory
         self.output = output
+        # noinspection PyUnresolvedReferences
         self.environ = environ or os.environ.copy()
+        self.python = python
 
         with ProcessPoolExecutor(max_workers=self.workers) as executor:
             # Consume the iterator to ensure all tasks complete

{sflkit-0.5.6 → sflkit-0.5.7/src/sflkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.6
+Version: 0.5.7
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/smythi93/sflkit/

{sflkit-0.5.6 → sflkit-0.5.7}/tests/test_runner.py

@@ -1,6 +1,6 @@
 import os
-import time
 from pathlib import Path
+from unittest.mock import patch, MagicMock
 
 from sflkit import Config, instrument_config, Analyzer
 from sflkit.analysis.analysis_type import AnalysisType
@@ -180,3 +180,71 @@ class RunnerTests(BaseTest):
             os.path.join("structure", "tests", "test_a.py::test_c"),
             tests,
         )
+
+    def test_runner_python_interpreter(self):
+        """
+        Test that the python argument is correctly passed to subprocess calls.
+        This test verifies that pytest collection uses the specified python
+        interpreter instead of the default 'python3'.
+        """
+        custom_python = "python3.11"
+
+        # Create a mock for subprocess.run
+        with patch("sflkit.runners.run.subprocess.run") as mock_run:
+            # Create a mock return value that simulates pytest collection output
+            mock_process = MagicMock()
+            mock_process.returncode = 0
+            mock_process.stdout = (
+                b"<Package tests>\n"
+                b"  <Module test_a.py>\n"
+                b"    <Function test_sample>\n"
+            )
+            mock_process.stderr = b""
+            mock_run.return_value = mock_process
+
+            # Create a pytest runner
+            runner = PytestRunner(set_python_path=True)
+
+            # Create a temporary directory for testing
+            test_dir = Path(BaseTest.TEST_DIR)
+            output_dir = test_dir / "events_python_test"
+
+            # Call runner.run with custom python interpreter
+            runner.run(
+                test_dir,
+                output_dir,
+                python=custom_python,
+            )
+
+            # Verify that subprocess.run was called
+            self.assertTrue(mock_run.called, "subprocess.run should have been called")
+
+            # Collect all the calls made to subprocess.run
+            calls = mock_run.call_args_list
+            self.assertGreater(
+                len(calls), 0, "Expected at least one call to subprocess.run"
+            )
+
+            # Check that the first call (pytest collection) uses the custom python interpreter
+            first_call_args = calls[0][0][0]  # Get the command list from the first call
+            self.assertIsInstance(first_call_args, list, "Command should be a list")
+            self.assertEqual(
+                first_call_args[0],
+                custom_python,
+                f"First subprocess call should start with {custom_python}, got {first_call_args[0]}",
+            )
+            self.assertIn(
+                "-m",
+                first_call_args,
+                "pytest collection call should contain -m argument",
+            )
+            self.assertIn(
+                "pytest",
+                first_call_args,
+                "pytest collection call should contain pytest argument",
+            )
+            self.assertIn(
+                "--collect-only",
+                first_call_args,
+                "pytest collection call should contain --collect-only argument",
+            )