sflkit 0.3.5__tar.gz → 0.5.0__tar.gz

{sflkit-0.3.5/src/sflkit.egg-info → sflkit-0.5.0}/PKG-INFO

@@ -1,41 +1,21 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: sflkit
-Version: 0.3.5
+Version: 0.5.0
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
-License: MIT License
-        
-        Copyright (c) 2022 Marius Smytzek
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
 Project-URL: Homepage, https://github.com/smythi93/sflkit/
 Project-URL: Bug Tracker, https://github.com/smythi93/sflkit/issues
 Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.10
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sflkitlib>=0.1.1
+Requires-Dist: sflkitlib>=0.2.1
 Requires-Dist: numpy>=2.1.3
 Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: pandas>=2.2.3
@@ -47,6 +27,7 @@ Requires-Dist: pytest-cov>=6.0.0; extra == "test"
 Requires-Dist: pytest-html>=4.1.1; extra == "test"
 Requires-Dist: pytest-rerunfailures>=15.0; extra == "test"
 Requires-Dist: parameterized>=0.9.0; extra == "test"
+Dynamic: license-file
 
 # SFLKit: A Workbench for Statistical Fault Localization
 

{sflkit-0.3.5 → sflkit-0.5.0}/pyproject.toml

@@ -7,23 +7,25 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sflkit"
-version = "0.3.5"
+dynamic = ["version"]
 authors = [
     { name = "Marius Smytzek", email = "marius.smytzek@cispa.de" },
 ]
 description = "SFLKit: : A Workbench for Statistical Fault Localization"
 readme = "README.md"
-license = { file = "LICENSE" }
+license-files = ["LICENSE*"]
 requires-python = ">=3.10"
 classifiers = [
     "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.10",
-    "License :: OSI Approved :: MIT License",
     "Topic :: Scientific/Engineering",
     "Topic :: Software Development :: Testing"
 ]
 dependencies = [
-    "sflkitlib>=0.1.1",
+    "sflkitlib>=0.2.1",
     "numpy>=2.1.3",
     "matplotlib>=3.10.0",
     "pandas>=2.2.3",
@@ -35,9 +37,16 @@ dependencies = [
 "Homepage" = "https://github.com/smythi93/sflkit/"
 "Bug Tracker" = "https://github.com/smythi93/sflkit/issues"
 
+[tool.setuptools.dynamic]
+version = {attr = "sflkit.__version__"}
+
 [project.scripts]
 sflkit = "sflkit.cli:main"
 
+# only include packages in src/
+[tool.setuptools.packages.find]
+where = ["src"]
+
 [project.optional-dependencies]
 test = [
     "pytest>=8.3.4",

{sflkit-0.3.5 → sflkit-0.5.0}/src/sflkit/__init__.py

@@ -6,6 +6,9 @@ from sflkit.config import Config, parse_config
 from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
 
+__version__ = "0.5.0"
+
+
 def instrument_config(conf: Config):
     instrumentation = DirInstrumentation(
         conf.visitor, conf.mapping.path, test_visitor=conf.test_visitor
@@ -54,10 +57,10 @@ def analyze_config(conf: Config, analysis_dump: PathLike = None):
         results[analysis_type.name] = dict()
         for metric in conf.metrics:
             try:
-                results[analysis_type.name][
-                    metric.__name__
-                ] = analyzer.get_sorted_suggestions(
-                    conf.target_path, metric, analysis_type
+                results[analysis_type.name][metric.__name__] = (
+                    analyzer.get_sorted_suggestions(
+                        conf.target_path, metric, analysis_type
+                    )
                 )
             except (AttributeError, ValueError, TypeError) as e:
                 raise e

{sflkit-0.3.5 → sflkit-0.5.0}/src/sflkit/analysis/analyzer.py

@@ -22,6 +22,7 @@ from sflkit.analysis.spectra import Line, Function, DefUse, Loop, Length
 from sflkit.analysis.suggestion import Suggestion
 from sflkit.events.event_file import EventFile
 from sflkit.model.model import Model, MetaModel
+from sflkit.model.parallel import ParallelModel
 
 
 class AnalysisEncoder(json.JSONEncoder):
@@ -39,7 +40,8 @@ class Analyzer:
         irrelevant_event_files: Optional[List[EventFile]] = None,
         factory: Optional[AnalysisFactory] = None,
         meta_model: Optional[MetaModel] = None,
-        model_class: Type[Model] = Model,
+        model_class: Type[Model] = None,
+        parallel: bool = False,
     ):
         if (
             relevant_event_files is None
@@ -56,6 +58,11 @@ class Analyzer:
         if self.meta:
             self.model = meta_model
         else:
+            if model_class is None:
+                if parallel:
+                    model_class = ParallelModel
+                else:
+                    model_class = Model
             self.model = model_class(factory)
         self.paths: Dict[int, os.PathLike] = dict()
         self.max_suspiciousness = 0

{sflkit-0.3.5 → sflkit-0.5.0}/src/sflkit/config.py

@@ -58,6 +58,8 @@ class Config:
 
     [test]
     runner=TestRunner                       : The testrunner class, None if no run needed
+    workers=number_of_workers               : Number of workers for parallel runners
+    thread_support=True|False               : Whether the subject uses threading
     """
 
     def __init__(self, path: Union[str, configparser.ConfigParser] = None):
@@ -82,6 +84,8 @@ class Config:
         self.instrument_test_files = list()
         self.instrument_working = None
         self.runner = None
+        self.workers = 1
+        self.thread_support = False
         self.mapping = None
         self.mapping_path = None
         self.events_id_generator = IDGenerator()
@@ -233,6 +237,23 @@ class Config:
                     test = config["test"]
                     if "runner" in test and test["runner"] != "None":
                         self.runner = RunnerType[test["runner"].upper()]
+                    if "workers" in test:
+                        self.workers = int(test["workers"])
+                        if (
+                            self.workers > 1
+                            and self.runner
+                            and not self.runner.name.startswith("PARALLEL_")
+                        ):
+                            self.runner = RunnerType["PARALLEL_" + self.runner.name]
+                    if "thread_support" in test:
+                        self.thread_support = test["thread_support"].lower() in [
+                            "True",
+                            "true",
+                            "1",
+                            "t",
+                            "y",
+                            "yes",
+                        ]
 
             except KeyError as e:
                 raise ConfigError(e)
@@ -258,6 +279,8 @@ class Config:
         instrument_test: Optional[List[str]] = None,
         instrument_working: Optional[str] = None,
         runner: Optional[RunnerType] = None,
+        workers: Optional[int] = 1,
+        thread_support: Optional[bool] = False,
     ):
         conf = Config()
         conf.target_path = target_path
@@ -280,6 +303,8 @@ class Config:
         conf.instrument_test = instrument_test or list()
         conf.instrument_working = instrument_working
         conf.runner = runner
+        conf.workers = workers or 1
+        conf.thread_support = thread_support
         if mapping:
             conf.mapping = mapping
             if mapping.path:
@@ -336,6 +361,8 @@ class Config:
         tests=None,
         test_files=None,
         runner=None,
+        workers=None,
+        thread_support=None,
     ):
         conf = configparser.ConfigParser()
         conf["target"] = dict()
@@ -375,6 +402,10 @@ class Config:
             conf["instrumentation"]["test_files"] = test_files
         if runner:
             conf["test"]["runner"] = runner
+        if workers:
+            conf["test"]["workers"] = str(workers)
+        if thread_support:
+            conf["test"]["thread_support"] = str(thread_support)
 
         return Config(conf)
 
@@ -425,6 +456,10 @@ class Config:
             )
         if self.runner:
             conf["test"]["runner"] = self.runner.name
+        if self.workers:
+            conf["test"]["workers"] = str(self.workers)
+        if self.thread_support:
+            conf["test"]["thread_support"] = str(self.thread_support)
 
         with open(path, "w") as fp:
             conf.write(fp)

{sflkit-0.3.5 → sflkit-0.5.0}/src/sflkit/events/event_file.py

@@ -13,11 +13,13 @@ class EventFile(object):
         run_id: int,
         mapping: EventMapping,
         failing: bool = False,
+        thread_support: bool = False,
     ):
         self.path = path
         self.run_id = run_id
         self.mapping = mapping
         self.failing = failing
+        self.thread_support = thread_support
         self._csv_reader = None
         self._file_pointer = None
 
@@ -37,7 +39,11 @@ class EventFile(object):
     def load(self):
         while self._file_pointer.peek(1):
             try:
-                e = event.load_next_event(self._file_pointer, self.mapping.mapping)
+                e = event.load_next_event(
+                    self._file_pointer,
+                    self.mapping.mapping,
+                    with_thread_id=self.thread_support,
+                )
                 if self.mapping.is_valid(e):
                     yield e
             except (IndexError, ValueError, PickleError, KeyError):

{sflkit-0.3.5 → sflkit-0.5.0}/src/sflkit/features/handler.py

@@ -78,14 +78,14 @@ class FeatureBuilder(CombinationFactory):
     def hit(self, id_, *args, **kwargs):
         event: Event
         for a in self.analysis:
-            if isinstance(a, Spectrum):
-                feature = BinaryFeature(str(a), a)
+            if isinstance(a, Predicate):
+                feature = TertiaryFeature(str(a), a)
                 self.feature_vectors[id_].set_feature(
                     feature, self.map_evaluation(a, id_)
                 )
                 self.all_features.add(feature)
-            elif isinstance(a, Predicate):
-                feature = TertiaryFeature(str(a), a)
+            elif isinstance(a, Spectrum):
+                feature = BinaryFeature(str(a), a)
                 self.feature_vectors[id_].set_feature(
                     feature, self.map_evaluation(a, id_)
                 )

sflkit-0.5.0/src/sflkit/model/parallel.py

@@ -0,0 +1,127 @@
+from typing import Set, List, Optional
+
+from sflkit.analysis.analysis_type import AnalysisObject
+from sflkit.events.event_file import EventFile
+from sflkit.model.model import Model
+from sflkit.model.scope import Scope
+
+
+class ParallelModel(Model):
+    def __init__(self, factory):
+        super().__init__(factory)
+        self.variables_map: dict[int, Scope] = dict()
+        self.returns_map: dict[int, Scope] = dict()
+
+    def prepare(self, event_file):
+        self.factory.reset()
+        self.variables = Scope()
+        self.returns = Scope()
+        self.current_event_file = event_file
+        self.variables_map = dict()
+        self.returns_map = dict()
+
+    def follow_up(self, event_file):
+        pass
+
+    def handle_line_event(self, event):
+        self.handle_event(event)
+
+    def handle_branch_event(self, event):
+        self.handle_event(event)
+
+    def handle_function_enter_event(self, event):
+        if event.thread_id is None:
+            self.enter_scope()
+        else:
+            self.enter_parallel_scope(event.thread_id)
+        self.handle_event(event)
+
+    def handle_function_exit_event(self, event):
+        if event.thread_id is None:
+            self.returns.add(event.function, event.return_value, event.type_)
+        else:
+            self.returns_map.setdefault(event.thread_id, Scope()).add(
+                event.function, event.return_value, event.type_
+            )
+        self.handle_event(event, self.returns)
+        if event.thread_id is None:
+            self.exit_scope()
+        else:
+            self.exit_parallel_scope(event.thread_id)
+
+    def handle_function_error_event(self, event):
+        self.handle_event(event)
+        if event.thread_id is None:
+            self.exit_scope()
+        else:
+            self.exit_parallel_scope(event.thread_id)
+
+    def handle_def_event(self, event):
+        if event.thread_id is None:
+            self.variables.add(event.var, event.value, event.type_)
+        else:
+            self.variables_map.setdefault(event.thread_id, self.variables).add(
+                event.var, event.value, event.type_
+            )
+        self.handle_event(event, self.variables)
+
+    def handle_use_event(self, event):
+        if event.thread_id is None:
+            self.handle_event(event, self.variables)
+        else:
+            self.handle_event(
+                event, self.variables_map.get(event.thread_id, self.variables)
+            )
+
+    def handle_condition_event(self, event):
+        self.handle_event(event)
+
+    def handle_loop_begin_event(self, event):
+        self.handle_event(event)
+
+    def handle_loop_hit_event(self, event):
+        self.handle_event(event)
+
+    def handle_loop_end_event(self, event):
+        self.handle_event(event)
+
+    def handle_len_event(self, event):
+        self.handle_event(event)
+
+    def handle_test_start_event(self, event):
+        pass
+
+    def handle_test_end_event(self, event):
+        pass
+
+    def handle_test_line_event(self, event):
+        pass
+
+    def handle_test_def_event(self, event):
+        pass
+
+    def handle_test_use_event(self, event):
+        pass
+
+    def handle_test_assert_event(self, event):
+        pass
+
+    def enter_parallel_scope(self, thread_id: int):
+        self.variables_map[thread_id] = self.variables_map.get(
+            thread_id, self.variables
+        ).enter()
+
+    def exit_parallel_scope(self, thread_id: int):
+        self.variables_map[thread_id] = self.variables_map.get(
+            thread_id, self.variables
+        ).exit()
+
+    # noinspection PyUnresolvedReferences
+    def get_analysis(self) -> Set[AnalysisObject]:
+        return self.factory.get_all()
+
+    def finalize(
+        self, passed: Optional[List[EventFile]], failed: Optional[List[EventFile]]
+    ):
+        for p in self.get_analysis():
+            p.analyze(passed, failed)

{sflkit-0.3.5 → sflkit-0.5.0}/src/sflkit/runners/__init__.py

@@ -6,6 +6,7 @@ from sflkit.runners.run import (
     PytestRunner,
     UnittestRunner,
     InputRunner,
+    ParallelPytestRunner,
 )
 
 
@@ -17,3 +18,5 @@ class RunnerType(enum.Enum):
     PYTEST_RUNNER = PytestRunner
     UNITTEST_RUNNER = UnittestRunner
     INPUT_RUNNER = InputRunner
+    PARALLEL_PYTEST_RUNNER = ParallelPytestRunner
+    PARALLEL_UNITTEST_RUNNER = UnittestRunner

{sflkit-0.3.5 → sflkit-0.5.0}/src/sflkit/runners/run.py

@@ -6,6 +6,8 @@ import re
 import shutil
 import string
 import subprocess
+import threading
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple, Set
 
@@ -35,7 +37,13 @@ class TestResult(enum.Enum):
 
 
 class Runner(abc.ABC):
-    def __init__(self, re_filter: str = r".*", timeout=DEFAULT_TIMEOUT):
+    def __init__(
+        self,
+        re_filter: str = r".*",
+        timeout=DEFAULT_TIMEOUT,
+        is_parallel: bool = False,
+        thread_support: bool = False,
+    ):
         self.timeout = timeout
         self.re_filter = re.compile(re_filter)
         self.passing_tests = set()
@@ -46,6 +54,12 @@ class Runner(abc.ABC):
             TestResult.FAILING: self.failing_tests,
             TestResult.UNDEFINED: self.undefined_tests,
         }
+        self.is_parallel = is_parallel
+        self.thread_support = thread_support
+
+    @staticmethod
+    def use_parallel() -> "Runner":
+        raise NotImplementedError()
 
     def get_tests(
         self,
@@ -94,6 +108,10 @@ class Runner(abc.ABC):
                     directory / "EVENTS_PATH",
                     output / test_result.get_dir() / self.safe(test),
                 )
+            else:
+                LOGGER.warning(f"EVENTS_PATH not found for test {test}")
+        # Ensure all files are flushed to disk (helps with race conditions in CI)
+        os.sync()
 
     def run(
         self,
@@ -107,6 +125,9 @@ class Runner(abc.ABC):
         self.passing_tests.clear()
         self.failing_tests.clear()
         self.undefined_tests.clear()
+        if environ is None:
+            environ = os.environ.copy()
+        environ["EVENTS_THREADS"] = "1" if self.thread_support else "0"
         self.run_tests(
             directory,
             output,
@@ -118,7 +139,9 @@ class Runner(abc.ABC):
 
 
 class VoidRunner(Runner):
-    pass
+    @staticmethod
+    def use_parallel() -> Runner:
+        return VoidRunner
 
 
 class PytestStructure:
@@ -262,10 +285,15 @@ class PytestRunner(Runner):
         re_filter: str = r".*",
         timeout=DEFAULT_TIMEOUT,
         set_python_path: bool = False,
+        thread_support: bool = False,
     ):
-        super().__init__(re_filter, timeout)
+        super().__init__(re_filter, timeout, thread_support=thread_support)
         self.set_python_path = set_python_path
 
+    @staticmethod
+    def use_parallel() -> Runner:
+        return ParallelPytestRunner
+
     @staticmethod
     def common_base(directory: Path, tests: List[str]) -> Path:
         parts = directory.parts
@@ -401,6 +429,7 @@ class PytestRunner(Runner):
             cwd=directory,
         )
         LOGGER.debug(f"pytest collection finished with {process.returncode}")
+        LOGGER.debug(process.stderr.decode("utf8"))
         tests = PytestStructure.parse_tests(process.stdout.decode("utf8"))
         LOGGER.debug(f"pytest collection found {len(tests)} tests")
         return self.normalize_paths(tests, file_bases, directory, root_dir)
@@ -460,13 +489,18 @@ class InputRunner(Runner):
         access: os.PathLike,
         passing: List[str | List[str]],
         failing: List[str | List[str]],
+        thread_support: bool = False,
     ):
-        super().__init__()
+        super().__init__(thread_support=thread_support)
         self.access = access
         self.passing: Dict[str, List[str]] = self._prepare_tests(passing, "passing")
         self.failing: Dict[str, List[str]] = self._prepare_tests(failing, "failing")
         self.output: Dict[str, Tuple[str, str]] = dict()
 
+    @staticmethod
+    def use_parallel() -> Runner:
+        return ParallelInputRunner
+
     @staticmethod
     def split(s: str, sep: str = ",", esc: str = "\"'"):
         values = list()
@@ -526,3 +560,114 @@ class InputRunner(Runner):
             process.stderr.decode("utf8"),
         )
         return result
+
+
+class ParallelPytestRunner(PytestRunner):
+    def __init__(
+        self,
+        re_filter: str = r".*",
+        timeout=DEFAULT_TIMEOUT,
+        set_python_path: bool = False,
+        workers: int = 4,
+        thread_support: bool = False,
+    ):
+        super().__init__(
+            re_filter, timeout, set_python_path, thread_support=thread_support
+        )
+        self.workers = workers
+        self.is_parallel = True
+
+    @staticmethod
+    def use_parallel() -> Runner:
+        return ParallelPytestRunner
+
+    def run_tests(
+        self,
+        directory: Path,
+        output: Path,
+        tests: List[str],
+        environ: Environment = None,
+    ):
+        output.mkdir(parents=True, exist_ok=True)
+        for test_result in TestResult:
+            (output / test_result.get_dir()).mkdir(parents=True, exist_ok=True)
+
+        def process_test(test: str):
+            if environ is None:
+                local_environ = os.environ.copy()
+            else:
+                local_environ = environ.copy()
+            events_path_name = f"EVENTS_PATH_{threading.get_ident()}"
+            local_environ["EVENTS_PATH"] = events_path_name
+            tr = self.run_test(directory, test, environ=local_environ)
+            self.tests[tr].add(test)
+            if os.path.exists(directory / events_path_name):
+                shutil.move(
+                    directory / events_path_name,
+                    output / tr.get_dir() / self.safe(test),
+                )
+            else:
+                LOGGER.warning(f"EVENTS_PATH not found for test {test}")
+
+        with ThreadPoolExecutor(max_workers=self.workers) as executor:
+            # Consume the iterator to ensure all tasks complete
+            list(executor.map(process_test, tests))
+
+        # Ensure all files are flushed to disk (helps with race conditions in CI)
+        os.sync()
+
+
+class ParallelInputRunner(InputRunner):
+    def __init__(
+        self,
+        access: os.PathLike,
+        passing: List[str | List[str]],
+        failing: List[str | List[str]],
+        workers: int = 4,
+        thread_support: bool = False,
+    ):
+        super().__init__(access, passing, failing, thread_support=thread_support)
+        self.workers = workers
+        self.is_parallel = True
+
+    @staticmethod
+    def use_parallel() -> Runner:
+        return ParallelInputRunner
+
+    def run_tests(
+        self,
+        directory: Path,
+        output: Path,
+        tests: List[str],
+        environ: Environment = None,
+    ):
+        output.mkdir(parents=True, exist_ok=True)
+        for test_result in TestResult:
+            (output / test_result.get_dir()).mkdir(parents=True, exist_ok=True)
+
+        lock = threading.Lock()
+
+        def process_test(test_name: str):
+            if environ is None:
+                local_environ = os.environ.copy()
+            else:
+                local_environ = environ.copy()
+            events_path_name = f"EVENTS_PATH_{threading.get_ident()}"
+            local_environ["EVENTS_PATH"] = events_path_name
+            tr = self.run_test(directory, test_name, environ=local_environ)
+            with lock:
+                self.tests[tr].add(test_name)
+            if os.path.exists(directory / events_path_name):
+                shutil.move(
+                    directory / events_path_name,
+                    output / tr.get_dir() / self.safe(test_name),
+                )
+            else:
+                LOGGER.warning(f"EVENTS_PATH not found for test {test_name}")
+
+        with ThreadPoolExecutor(max_workers=self.workers) as executor:
+            # Consume the iterator to ensure all tasks complete
+            list(executor.map(process_test, tests))
+
+        # Ensure all files are flushed to disk (helps with race conditions in CI)
+        os.sync()