sflkit 0.5.6__tar.gz → 1.0.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.6
+Version: 1.0.0
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
 Author-email: Marius Smytzek <marius.smytzek@cispa.de>
 Project-URL: Homepage, https://github.com/smythi93/sflkit/
@@ -15,12 +15,12 @@ Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sflkitlib>=0.2.2
+Requires-Dist: sflkitlib>=0.2.4
 Requires-Dist: numpy>=2.1.3
 Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: sortedcollections>=2.1.0
-Requires-Dist: java-ast>=1.0.2
+Requires-Dist: java-ast>=1.0.3
 Provides-Extra: test
 Requires-Dist: pytest>=8.3.4; extra == "test"
 Requires-Dist: pytest-cov>=6.0.0; extra == "test"
@@ -45,7 +45,16 @@ whether individual lines are part of the execution.
 
 ## Language Support
 
-SFLKit supports currently Python 3 but we plan on releasing further language support.
+SFLKit supports Python 3 and Java.
+
+Python is instrumented with the standard `ast` module. Events can also be collected
+without instrumenting anything, by tracing the program as it runs; see
+`sflkit.online`.
+
+Java is instrumented with [jast](https://github.com/smythi93/jast) and traced by the
+`jsflkit` runtime, which produces the same events as the Python side, so every
+spectrum, predicate and metric applies unchanged. A runner for
+[Defects4J](https://github.com/rjust/defects4j) collects traces per test.
 
 ## Installation
 

{sflkit-0.5.6 → sflkit-1.0.0}/README.md

@@ -14,7 +14,16 @@ whether individual lines are part of the execution.
 
 ## Language Support
 
-SFLKit supports currently Python 3 but we plan on releasing further language support.
+SFLKit supports Python 3 and Java.
+
+Python is instrumented with the standard `ast` module. Events can also be collected
+without instrumenting anything, by tracing the program as it runs; see
+`sflkit.online`.
+
+Java is instrumented with [jast](https://github.com/smythi93/jast) and traced by the
+`jsflkit` runtime, which produces the same events as the Python side, so every
+spectrum, predicate and metric applies unchanged. A runner for
+[Defects4J](https://github.com/rjust/defects4j) collects traces per test.
 
 ## Installation
 

{sflkit-0.5.6 → sflkit-1.0.0}/pyproject.toml

@@ -25,12 +25,12 @@ classifiers = [
     "Topic :: Software Development :: Testing"
 ]
 dependencies = [
-    "sflkitlib>=0.2.2",
+    "sflkitlib>=0.2.4",
     "numpy>=2.1.3",
     "matplotlib>=3.10.0",
     "pandas>=2.2.3",
     "sortedcollections>=2.1.0",
-    "java-ast>=1.0.2",
+    "java-ast>=1.0.3",
 ]
 
 [project.urls]
@@ -47,6 +47,9 @@ sflkit = "sflkit.cli:main"
 [tool.setuptools.packages.find]
 where = ["src"]
 
+[tool.setuptools.package-data]
+"sflkit.runners" = ["resources/*.java"]
+
 [project.optional-dependencies]
 test = [
     "pytest>=8.3.4",

{sflkit-0.5.6 → sflkit-1.0.0}/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__ = "1.0.0"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.6 → sflkit-1.0.0}/src/sflkit/analysis/analyzer.py

@@ -1,6 +1,7 @@
 import json
 import os
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
+from operator import itemgetter
 from typing import List, Callable, Set, Dict, Optional, Any, Type
 
 from sflkit.analysis.analysis_type import AnalysisType, AnalysisObject
@@ -25,6 +26,60 @@ from sflkit.events.event_file import EventFile
 from sflkit.model.model import Model, MetaModel
 from sflkit.model.parallel import ParallelModel
 
+_key_of = itemgetter(0)
+
+
+def analyze_files(
+    factory: AnalysisFactory, event_files: List[EventFile]
+) -> Set[AnalysisObject]:
+    """
+    Analyze a share of the runs, start to finish, in one process.
+
+    Defined at module level so it can be shipped to a worker process, and kept
+    free of shared state so that workers never have to talk to each other: the
+    runs are partitioned, so the per-run state each worker accumulates is
+    disjoint from every other worker's and merges by simple union.
+
+    Suspiciousness is deliberately *not* computed here. It is a property of the
+    whole suite, so it can only be derived once every worker's share has been
+    merged.
+
+    :param factory: A fresh analysis factory.
+    :param event_files: The runs this worker is responsible for.
+    :returns: The analysis objects it built.
+    """
+    model = Model(factory)
+    for event_file in event_files:
+        model.prepare(event_file)
+        with event_file:
+            for event in event_file.load():
+                event.handle(model, event_file)
+        model.follow_up(event_file)
+    return model.get_analysis()
+
+
+def merge_analysis(target: AnalysisObject, source: AnalysisObject) -> None:
+    """
+    Fold a worker's view of one analysis object into the parent's.
+
+    Everything an object accumulates while events are handled is keyed by run,
+    and workers hold disjoint runs, so merging is a dictionary update. Which
+    attributes those are is discovered rather than hard-coded, so a subclass
+    that adds per-run state of its own is merged too instead of silently
+    losing it.
+
+    :param target: The object the parent keeps.
+    :param source: The equal object a worker produced.
+    """
+    for name, value in vars(source).items():
+        if not isinstance(value, dict) or not value:
+            continue
+        if not all(isinstance(key, EventFile) for key in value):
+            continue
+        current = getattr(target, name, None)
+        if isinstance(current, dict):
+            current.update(value)
+
 
 class AnalysisEncoder(json.JSONEncoder):
     def default(self, o: Any) -> Any:
@@ -44,6 +99,7 @@ class Analyzer:
         model_class: Type[Model] = None,
         parallel: bool = False,
         workers: int = 4,
+        processes: int = 1,
     ):
         if (
             relevant_event_files is None
@@ -67,6 +123,10 @@ class Analyzer:
                     model_class = Model
             self.model = model_class(factory)
         self.workers = workers
+        #: Worker processes to spread the runs over. Threads cannot help here:
+        #: analysis is Python-level work and the GIL serializes it, while runs
+        #: are independent until suspiciousness is computed.
+        self.processes = processes
         self.paths: Dict[int, os.PathLike] = dict()
         self.max_suspiciousness = 0
         self.min_suspiciousness = 0
@@ -87,9 +147,49 @@ class Analyzer:
             raise NotImplementedError("Not implemented for meta/loaded analyzer")
         self.model.finalize(self.irrelevant_event_files, self.relevant_event_files)
 
+    def _analyze_with_processes(self, event_files: List[EventFile]):
+        """
+        Analyze *event_files* across worker processes and merge the results.
+
+        :param event_files: Every run to analyze.
+
+        Uses :class:`~concurrent.futures.ProcessPoolExecutor`, so on platforms
+        that start workers with ``spawn`` (macOS, Windows) the calling program
+        must guard its entry point with ``if __name__ == "__main__":``, as with
+        any use of multiprocessing.
+        """
+        chunks: List[List[EventFile]] = [[] for _ in range(self.processes)]
+        # Round-robin rather than contiguous: runs differ wildly in length, and
+        # dealing them out keeps a worker from drawing all the long ones.
+        for index, event_file in enumerate(event_files):
+            chunks[index % self.processes].append(event_file)
+        chunks = [chunk for chunk in chunks if chunk]
+        merged: Dict[AnalysisObject, AnalysisObject] = dict()
+        with ProcessPoolExecutor(max_workers=len(chunks)) as executor:
+            futures = [
+                executor.submit(analyze_files, self.model.factory, chunk)
+                for chunk in chunks
+            ]
+            for future in futures:
+                for analysis in future.result():
+                    known = merged.get(analysis)
+                    if known is None:
+                        merged[analysis] = analysis
+                    else:
+                        merge_analysis(known, analysis)
+        # The factory owns the objects the rest of the analyzer reads back.
+        self.model.factory.adopt(merged.values())
+
     def analyze(self):
         if self.meta:
             raise NotImplementedError("Not implemented for meta/loaded analyzer")
+        if self.processes > 1:
+            event_files = self.relevant_event_files + self.irrelevant_event_files
+            for event_file in event_files:
+                self.paths[event_file.run_id] = event_file.path
+            self._analyze_with_processes(event_files)
+            self._finalize()
+            return
         if self.workers > 1:
             event_files = self.relevant_event_files + self.irrelevant_event_files
             for event_file in event_files:
@@ -155,11 +255,15 @@ class Analyzer:
             ),
             analysis,
         ):
-            suspiciousness.append(suggestion.suspiciousness)
-            if suggestion.suspiciousness not in suggestions:
-                suggestions[suggestion.suspiciousness] = set(suggestion.lines)
+            value = suggestion.suspiciousness
+            suspiciousness.append(value)
+            lines = suggestions.get(value)
+            if lines is None:
+                suggestions[value] = set(suggestion.lines)
             else:
-                suggestions[suggestion.suspiciousness] |= set(suggestion.lines)
+                # Union with a set, not update with the list: the two insert in a
+                # different order, and that decides the order of Suggestion.lines.
+                lines |= set(suggestion.lines)
 
         if suspiciousness:
             self.max_suspiciousness = max(suspiciousness)
@@ -169,13 +273,12 @@ class Analyzer:
                 len(suspiciousness) // 2
             ]
 
-        return sorted(
-            [
-                Suggestion(list(lines), suspiciousness)
-                for suspiciousness, lines in suggestions.items()
-            ],
-            reverse=True,
-        )[:]
+        # Sorting on the key skips Suggestion's rich comparisons; the order is
+        # the same, because that is the only thing a suggestion compares.
+        return [
+            Suggestion(list(lines), value)
+            for value, lines in sorted(suggestions.items(), key=_key_of, reverse=True)
+        ]
 
     def get_coverage_per_run(
         self, type_: AnalysisType = None