sflkit 0.5.0__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.0
+Version: 0.5.2
 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,7 +15,7 @@ Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sflkitlib>=0.2.1
+Requires-Dist: sflkitlib>=0.2.2
 Requires-Dist: numpy>=2.1.3
 Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: pandas>=2.2.3

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

@@ -25,7 +25,7 @@ classifiers = [
     "Topic :: Software Development :: Testing"
 ]
 dependencies = [
-    "sflkitlib>=0.2.1",
+    "sflkitlib>=0.2.2",
     "numpy>=2.1.3",
     "matplotlib>=3.10.0",
     "pandas>=2.2.3",

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

@@ -6,7 +6,7 @@ from sflkit.config import Config, parse_config
 from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
 
-__version__ = "0.5.0"
+__version__ = "0.5.2"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.0 → sflkit-0.5.2}/src/sflkit/analysis/analysis_type.py

@@ -1,6 +1,6 @@
+import abc
 import enum
-from abc import abstractmethod
-from typing import List, Type, Optional
+from typing import List, Type, Optional, Any
 
 from sflkit.events.event_file import EventFile
 from sflkit.model.scope import Scope
@@ -43,7 +43,7 @@ If you want to add new spectra or predicates, please register them here and in s
 """
 
 
-class AnalysisObject:
+class AnalysisObject(abc.ABC):
     function_finder = None
     loop_finder = None
     branch_finder = None
@@ -58,17 +58,17 @@ class AnalysisObject:
     def __init__(self):
         self.suspiciousness: float = 0
         self.last_evaluation: EvaluationResult = EvaluationResult.UNOBSERVED
-        self.hits = dict()
+        self.hits: dict[EventFile, dict[Optional[int], Any]] = dict()
 
     def adjust_weight(self, event_file: EventFile, weight: float):
         pass
 
-    @abstractmethod
+    @abc.abstractmethod
     def serialize(self) -> dict:
         pass
 
     @staticmethod
-    @abstractmethod
+    @abc.abstractmethod
     def deserialize(s: dict) -> "AnalysisObject":
         pass
 
@@ -82,7 +82,7 @@ class AnalysisObject:
         return f"{self.analysis_type()}"
 
     @staticmethod
-    @abstractmethod
+    @abc.abstractmethod
     def analysis_type() -> AnalysisType:
         raise NotImplementedError()
 
@@ -93,19 +93,19 @@ class AnalysisObject:
     def calculate(self):
         pass
 
-    @abstractmethod
+    @abc.abstractmethod
     def finalize(self, passed: List, failed: List):
         raise NotImplementedError()
 
-    @abstractmethod
-    def hit(self, id_, event, scope_: Scope = None):
+    @abc.abstractmethod
+    def hit(self, id_: EventFile, event, scope: Scope = None):
         raise NotImplementedError()
 
-    @abstractmethod
+    @abc.abstractmethod
     def get_suggestion(self):
         raise NotImplementedError()
 
-    @abstractmethod
+    @abc.abstractmethod
     def assign_suspiciousness(self):
         raise NotImplementedError()
 
@@ -114,7 +114,7 @@ class AnalysisObject:
         return any(map(lambda e: isinstance(event, e), events))
 
     @staticmethod
-    @abstractmethod
+    @abc.abstractmethod
     def events() -> List[Type]:
         raise NotImplementedError()
 

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

@@ -1,5 +1,6 @@
 import json
 import os
+from concurrent.futures import ThreadPoolExecutor
 from typing import List, Callable, Set, Dict, Optional, Any, Type
 
 from sflkit.analysis.analysis_type import AnalysisType, AnalysisObject
@@ -42,6 +43,7 @@ class Analyzer:
         meta_model: Optional[MetaModel] = None,
         model_class: Type[Model] = None,
         parallel: bool = False,
+        workers: int = 4,
     ):
         if (
             relevant_event_files is None
@@ -64,6 +66,7 @@ class Analyzer:
                 else:
                     model_class = Model
             self.model = model_class(factory)
+        self.workers = workers
         self.paths: Dict[int, os.PathLike] = dict()
         self.max_suspiciousness = 0
         self.min_suspiciousness = 0
@@ -76,7 +79,7 @@ class Analyzer:
         self.model.prepare(event_file)
         with event_file:
             for event in event_file.load():
-                event.handle(self.model)
+                event.handle(self.model, event_file)
         self.model.follow_up(event_file)
 
     def _finalize(self):
@@ -87,9 +90,16 @@ class Analyzer:
     def analyze(self):
         if self.meta:
             raise NotImplementedError("Not implemented for meta/loaded analyzer")
-        for event_file in self.relevant_event_files + self.irrelevant_event_files:
-            self.paths[event_file.run_id] = event_file.path
-            self._analyze(event_file)
+        if self.workers > 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
+            with ThreadPoolExecutor(max_workers=self.workers) as executor:
+                list(executor.map(self._analyze, event_files))
+        else:
+            for event_file in self.relevant_event_files + self.irrelevant_event_files:
+                self.paths[event_file.run_id] = event_file.path
+                self._analyze(event_file)
         self._finalize()
 
     def dump(self, path: os.PathLike, indent: Optional[int] = None):

{sflkit-0.5.0 → sflkit-0.5.2}/src/sflkit/analysis/factory.py

@@ -1,8 +1,9 @@
 import abc
-from abc import abstractmethod
+from threading import Lock
 from typing import List, Type, Set
 
 from sflkitlib.events import EventType
+from sflkitlib.events.event import DefEvent
 
 from sflkit.analysis.analysis_type import AnalysisObject, AnalysisType
 from sflkit.analysis.predicate import (
@@ -21,25 +22,29 @@ from sflkit.analysis.predicate import (
     FunctionErrorPredicate,
 )
 from sflkit.analysis.spectra import Line, Function, Loop, DefUse, Length
+from sflkit.events.event_file import EventFile
 from sflkit.model.scope import Scope
 
 
-class AnalysisFactory:
+class AnalysisFactory(abc.ABC):
     def __init__(self):
         self.objects = dict()
+        self._lock = Lock()
 
-    @abstractmethod
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    @abc.abstractmethod
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         raise NotImplementedError()
 
-    def handle(self, event, scope: Scope = None):
-        analysis = self.get_analysis(event, scope=scope)
+    def handle(self, event, event_file: EventFile, scope: Scope = None):
+        analysis = self.get_analysis(event, event_file, scope=scope)
         if analysis:
             return analysis
         else:
             return self.default()
 
-    def reset(self):
+    def reset(self, event_file: EventFile):
         pass
 
     @staticmethod
@@ -55,25 +60,32 @@ class CombinationFactory(AnalysisFactory):
         super().__init__()
         self.factories = factories
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         return sum(
-            [factory.handle(event, scope) for factory in self.factories], start=list()
+            [factory.handle(event, event_file, scope) for factory in self.factories],
+            start=list(),
         )
 
-    def reset(self):
-        [f.reset() for f in self.factories]
+    def reset(self, event_file: EventFile):
+        [f.reset(event_file) for f in self.factories]
 
     def get_all(self) -> Set[AnalysisObject]:
         return set().union(*map(lambda f: f.get_all(), self.factories))
 
 
 class LineFactory(AnalysisFactory):
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.LINE:
             key = (Line.analysis_type(), event.file, event.line)
-            if key not in self.objects:
-                self.objects[key] = Line(event)
+            with self._lock:
+                if key not in self.objects:
+                    self.objects[key] = Line(event)
             return [self.objects[key]]
+        return None
 
 
 class BranchFactory(AnalysisFactory):
@@ -81,12 +93,15 @@ class BranchFactory(AnalysisFactory):
         super().__init__()
         self.else_ = else_
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.BRANCH:
             key = (Branch.analysis_type(), event.file, event.line, event.then_id)
             then = event.then_id < event.else_id
-            if key not in self.objects:
-                self.objects[key] = Branch(event, then=then)
+            with self._lock:
+                if key not in self.objects:
+                    self.objects[key] = Branch(event, then=then, then_id=event.then_id)
             if self.else_ and event.else_id >= 0:
                 else_key = (
                     Branch.analysis_type(),
@@ -94,19 +109,28 @@ class BranchFactory(AnalysisFactory):
                     event.line,
                     event.else_id,
                 )
-                if else_key not in self.objects:
-                    self.objects[else_key] = Branch(event, then=not then)
+                with self._lock:
+                    if else_key not in self.objects:
+                        self.objects[else_key] = Branch(
+                            event, then=not then, then_id=event.else_id
+                        )
                 return [self.objects[key], self.objects[else_key]]
             return [self.objects[key]]
 
+        return None
+
 
 class FunctionFactory(AnalysisFactory):
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.FUNCTION_ENTER:
             key = (Function.analysis_type(), event.file, event.line, event.function_id)
-            if key not in self.objects:
-                self.objects[key] = Function(event)
+            with self._lock:
+                if key not in self.objects:
+                    self.objects[key] = Function(event)
             return [self.objects[key]]
+        return None
 
 
 class LoopFactory(AnalysisFactory):
@@ -119,60 +143,74 @@ class LoopFactory(AnalysisFactory):
     def get_all(self) -> Set[AnalysisObject]:
         return set(obj for value in self.objects.values() for obj in value)
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type in (
             EventType.LOOP_BEGIN,
             EventType.LOOP_HIT,
             EventType.LOOP_END,
         ):
             key = (Loop.analysis_type(), event.file, event.line, event.loop_id)
-            if key not in self.objects:
-                self.objects[key] = []
-                if self.hit_0:
-                    self.objects[key].append(Loop(event, Loop.evaluate_hit_0)),
-                if self.hit_1:
-                    self.objects[key].append(Loop(event, Loop.evaluate_hit_1)),
-                if self.hit_more:
-                    self.objects[key].append(Loop(event, Loop.evaluate_hit_more)),
+            with self._lock:
+                if key not in self.objects:
+                    self.objects[key] = []
+                    if self.hit_0:
+                        self.objects[key].append(Loop(event, Loop.evaluate_hit_0)),
+                    if self.hit_1:
+                        self.objects[key].append(Loop(event, Loop.evaluate_hit_1)),
+                    if self.hit_more:
+                        self.objects[key].append(Loop(event, Loop.evaluate_hit_more)),
             if event.event_type == EventType.LOOP_BEGIN:
-                list(map(Loop.start_loop, self.objects[key]))
+                for obj in self.objects[key]:
+                    obj.start_loop(thread_id=event.thread_id)
             elif event.event_type == EventType.LOOP_HIT:
-                list(map(Loop.hit_loop, self.objects[key]))
+                for obj in self.objects[key]:
+                    obj.hit_loop(thread_id=event.thread_id)
             elif event.event_type == EventType.LOOP_END:
                 return self.objects[key][:]
             return list()
+        return None
 
 
 class DefUseFactory(AnalysisFactory):
     def __init__(self):
         super().__init__()
-        self.id_to_def = dict()
+        self.id_to_def: dict[EventFile, dict[tuple[str, int], DefEvent]] = dict()
 
-    def reset(self):
-        self.id_to_def = dict()
+    def reset(self, event_file: EventFile):
+        with self._lock:
+            self.id_to_def[event_file] = dict()
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.DEF:
-            self.id_to_def[(event.var, event.var_id)] = event
+            with self._lock:
+                self.id_to_def[event_file][(event.var, event.var_id)] = event
         elif event.event_type == EventType.USE:
-            if (event.var, event.var_id) in self.id_to_def:
+            with self._lock:
+                def_event = self.id_to_def[event_file].get((event.var, event.var_id))
+            if def_event:
                 key = (
                     DefUse.analysis_type(),
-                    self.id_to_def[(event.var, event.var_id)].file,
-                    self.id_to_def[(event.var, event.var_id)].line,
+                    def_event.file,
+                    def_event.line,
                     event.file,
                     event.line,
                     event.var,
                 )
-                if key not in self.objects:
-                    self.objects[key] = DefUse(
-                        self.id_to_def[(event.var, event.var_id)], event
-                    )
+                with self._lock:
+                    if key not in self.objects:
+                        self.objects[key] = DefUse(def_event, event)
                 return [self.objects[key]]
+        return None
 
 
 class ConditionFactory(AnalysisFactory):
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         objects = list()
         if event.event_type == EventType.CONDITION:
             for negate in (True, False):
@@ -183,10 +221,11 @@ class ConditionFactory(AnalysisFactory):
                     event.condition,
                     negate,
                 )
-                if key not in self.objects:
-                    self.objects[key] = Condition(
-                        event.file, event.line, event.condition, negate=negate
-                    )
+                with self._lock:
+                    if key not in self.objects:
+                        self.objects[key] = Condition(
+                            event.file, event.line, event.condition, negate=negate
+                        )
                 objects.append(self.objects[key])
         return objects
 
@@ -218,7 +257,9 @@ class ComparisonFactory(AnalysisFactory, abc.ABC):
 
 
 class ScalarPairFactory(ComparisonFactory):
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.DEF:
             variables = scope.get_all_vars()
             objects = list()
@@ -238,10 +279,11 @@ class ScalarPairFactory(ComparisonFactory):
                                             comp,
                                             types[0],
                                         )
-                                        if key not in self.objects:
-                                            self.objects[key] = ScalarPair(
-                                                event, comp, variable.var
-                                            )
+                                        with self._lock:
+                                            if key not in self.objects:
+                                                self.objects[key] = ScalarPair(
+                                                    event, comp, variable.var
+                                                )
                                         objects.append(self.objects[key])
             else:
                 for variable in variables:
@@ -257,16 +299,20 @@ class ScalarPairFactory(ComparisonFactory):
                                     comp,
                                     event.type_,
                                 )
-                                if key not in self.objects:
-                                    self.objects[key] = ScalarPair(
-                                        event, comp, variable.var
-                                    )
+                                with self._lock:
+                                    if key not in self.objects:
+                                        self.objects[key] = ScalarPair(
+                                            event, comp, variable.var
+                                        )
                                 objects.append(self.objects[key])
             return objects
+        return None
 
 
 class VariableFactory(ComparisonFactory):
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.DEF and event.type_ in [
             "int",
             "float",
@@ -282,14 +328,18 @@ class VariableFactory(ComparisonFactory):
                     comp,
                     "int",
                 )
-                if key not in self.objects:
-                    self.objects[key] = VariablePredicate(event, comp)
+                with self._lock:
+                    if key not in self.objects:
+                        self.objects[key] = VariablePredicate(event, comp)
                 objects.append(self.objects[key])
             return objects
+        return None
 
 
 class ReturnFactory(ComparisonFactory):
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.FUNCTION_EXIT:
             objects = list()
             if event.type_ in ("int", "float", "bool", "str", "bytes"):
@@ -312,10 +362,13 @@ class ReturnFactory(ComparisonFactory):
                             comp,
                             type_,
                         )
-                        if key not in self.objects:
-                            self.objects[key] = ReturnPredicate(event, comp, value=tr)
-                        objects.append(self.objects[key])
-            if event.type_ == "NoneType":
+                        with self._lock:
+                            if key not in self.objects:
+                                self.objects[key] = ReturnPredicate(
+                                    event, comp, value=tr
+                                )
+                            objects.append(self.objects[key])
+            elif event.type_ == "NoneType":
                 for comp in Comp.EQ, Comp.NE:
                     if comp in self.comparators:
                         key = (
@@ -326,8 +379,11 @@ class ReturnFactory(ComparisonFactory):
                             comp,
                             event.type_,
                         )
-                        if key not in self.objects:
-                            self.objects[key] = ReturnPredicate(event, comp, value=None)
+                        with self._lock:
+                            if key not in self.objects:
+                                self.objects[key] = ReturnPredicate(
+                                    event, comp, value=None
+                                )
                         objects.append(self.objects[key])
             else:
                 for comp in Comp.EQ, Comp.NE:
@@ -340,9 +396,14 @@ class ReturnFactory(ComparisonFactory):
                             comp,
                             "NoneType",
                         )
-                        if key in self.objects:
-                            objects.append(self.objects[key])
+                        with self._lock:
+                            if key not in self.objects:
+                                self.objects[key] = ReturnPredicate(
+                                    event, comp, value=None
+                                )
+                        objects.append(self.objects[key])
             return objects
+        return None
 
 
 class ConstantCompFactory(AnalysisFactory):
@@ -350,7 +411,9 @@ class ConstantCompFactory(AnalysisFactory):
         super().__init__()
         self.class_ = class_
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.DEF:
             objects = list()
             for comp in Comp.EQ, Comp.NE:
@@ -361,10 +424,13 @@ class ConstantCompFactory(AnalysisFactory):
                     event.var,
                     comp,
                 )
-                if key not in self.objects:
-                    self.objects[key] = self.class_(event)
+                with self._lock:
+                    if key not in self.objects:
+                        # noinspection PyArgumentList
+                        self.objects[key] = self.class_(event)
                 objects.append(self.objects[key])
             return objects
+        return None
 
 
 class NoneFactory(ConstantCompFactory):
@@ -387,7 +453,9 @@ class PredicateFunctionFactory(AnalysisFactory):
         super().__init__()
         self.class_ = class_
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.DEF:
             key = (
                 self.class_.analysis_type(),
@@ -395,9 +463,12 @@ class PredicateFunctionFactory(AnalysisFactory):
                 event.line,
                 event.var,
             )
-            if key not in self.objects:
-                self.objects[key] = self.class_(event)
+            with self._lock:
+                if key not in self.objects:
+                    # noinspection PyArgumentList
+                    self.objects[key] = self.class_(event)
             return [self.objects[key]]
+        return None
 
 
 class IsAsciiFactory(PredicateFunctionFactory):
@@ -427,20 +498,28 @@ class LengthFactory(AnalysisFactory):
     def get_all(self) -> Set[AnalysisObject]:
         return set(obj for value in self.objects.values() for obj in value)
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.LEN:
             key = (Length.analysis_type(), event.file, event.line, event.var)
-            if key not in self.objects:
-                self.objects[key] = []
-                if self.length_0:
-                    self.objects[key].append(Length(event, Length.evaluate_length_0)),
-                if self.length_1:
-                    self.objects[key].append(Length(event, Length.evaluate_length_1)),
-                if self.length_more:
-                    self.objects[key].append(
-                        Length(event, Length.evaluate_length_more)
-                    ),
+            with self._lock:
+                if key not in self.objects:
+                    self.objects[key] = []
+                    if self.length_0:
+                        self.objects[key].append(
+                            Length(event, Length.evaluate_length_0)
+                        ),
+                    if self.length_1:
+                        self.objects[key].append(
+                            Length(event, Length.evaluate_length_1)
+                        ),
+                    if self.length_more:
+                        self.objects[key].append(
+                            Length(event, Length.evaluate_length_more)
+                        )
             return self.objects[key][:]
+        return None
 
 
 class FunctionErrorFactory(AnalysisFactory):
@@ -448,22 +527,28 @@ class FunctionErrorFactory(AnalysisFactory):
         super().__init__()
         self.function_mapping = dict()
 
-    def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+    def get_analysis(
+        self, event, event_file: EventFile, scope: Scope = None
+    ) -> List[AnalysisObject]:
         if event.event_type == EventType.FUNCTION_ENTER:
-            self.function_mapping[event.function_id] = event.line
+            with self._lock:
+                self.function_mapping[event.function_id] = event.line
         if event.event_type in (EventType.FUNCTION_ERROR, EventType.FUNCTION_EXIT):
-            line = self.function_mapping.get(event.function_id, event.line)
+            with self._lock:
+                line = self.function_mapping.get(event.function_id, event.line)
             key = (
                 FunctionErrorPredicate.analysis_type(),
                 event.file,
                 line,
                 event.function_id,
             )
-            if key not in self.objects:
-                self.objects[key] = FunctionErrorPredicate(
-                    event.file, line, event.function
-                )
+            with self._lock:
+                if key not in self.objects:
+                    self.objects[key] = FunctionErrorPredicate(
+                        event.file, line, event.function
+                    )
             return [self.objects[key]]
+        return None
 
 
 analysis_factory_mapping = {