sflkit 0.5.1__tar.gz → 0.5.3__tar.gz

{sflkit-0.5.1/src/sflkit.egg-info → sflkit-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.1
+Version: 0.5.3
 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.1 → sflkit-0.5.3}/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.1"
+__version__ = "0.5.3"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.1 → sflkit-0.5.3}/src/sflkit/analysis/factory.py

@@ -179,28 +179,30 @@ class DefUseFactory(AnalysisFactory):
         self.id_to_def: dict[EventFile, dict[tuple[str, int], DefEvent]] = dict()
 
     def reset(self, event_file: EventFile):
-        self.id_to_def[event_file] = dict()
+        with self._lock:
+            self.id_to_def[event_file] = dict()
 
     def get_analysis(
         self, event, event_file: EventFile, scope: Scope = None
     ) -> List[AnalysisObject]:
         if event.event_type == EventType.DEF:
-            self.id_to_def[event_file][(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[event_file]:
+            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_file][(event.var, event.var_id)].file,
-                    self.id_to_def[event_file][(event.var, event.var_id)].line,
+                    def_event.file,
+                    def_event.line,
                     event.file,
                     event.line,
                     event.var,
                 )
                 with self._lock:
                     if key not in self.objects:
-                        self.objects[key] = DefUse(
-                            self.id_to_def[event_file][(event.var, event.var_id)], event
-                        )
+                        self.objects[key] = DefUse(def_event, event)
                 return [self.objects[key]]
         return None
 
@@ -265,24 +267,23 @@ class ScalarPairFactory(ComparisonFactory):
                 for types in (["int", "float", "bool"], ["str"], ["bytes"]):
                     if event.type_ in types:
                         for variable in variables:
-                            if variable.var != event.var:
-                                if variable.type_ in types:
-                                    for comp in self.comparators:
-                                        key = (
-                                            ScalarPair.analysis_type(),
-                                            event.file,
-                                            event.line,
-                                            event.var,
-                                            variable.var,
-                                            comp,
-                                            types[0],
-                                        )
-                                        with self._lock:
-                                            if key not in self.objects:
-                                                self.objects[key] = ScalarPair(
-                                                    event, comp, variable.var
-                                                )
-                                        objects.append(self.objects[key])
+                            if variable.type_ in types:
+                                for comp in self.comparators:
+                                    key = (
+                                        ScalarPair.analysis_type(),
+                                        event.file,
+                                        event.line,
+                                        event.var,
+                                        variable.var,
+                                        comp,
+                                        types[0],
+                                    )
+                                    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:
                     if variable.type_ == event.type_:
@@ -365,8 +366,8 @@ class ReturnFactory(ComparisonFactory):
                                 self.objects[key] = ReturnPredicate(
                                     event, comp, value=tr
                                 )
-                        objects.append(self.objects[key])
-            if event.type_ == "NoneType":
+                            objects.append(self.objects[key])
+            elif event.type_ == "NoneType":
                 for comp in Comp.EQ, Comp.NE:
                     if comp in self.comparators:
                         key = (
@@ -394,8 +395,12 @@ 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
 
@@ -525,9 +530,11 @@ class FunctionErrorFactory(AnalysisFactory):
         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,

{sflkit-0.5.1 → sflkit-0.5.3}/src/sflkit/analysis/spectra.py

@@ -958,7 +958,7 @@ class Length(ModifiableSpectrum):
         )
         if id_ in self.hits:
             if event.thread_id in self.hits[id_]:
-                self.hits[id_][event.thread_id].appent(event.length)
+                self.hits[id_][event.thread_id].append(event.length)
             else:
                 self.hits[id_][event.thread_id] = [event.length]
             self.last_evaluation[id_][event.thread_id] = result

{sflkit-0.5.1 → sflkit-0.5.3}/src/sflkit/features/handler.py

@@ -3,6 +3,7 @@ from concurrent.futures import ThreadPoolExecutor
 from typing import List, Dict, Set, Optional
 
 import pandas as pd
+from sflkitlib.events.event import Event
 
 from sflkit.analysis.analysis_type import AnalysisObject, EvaluationResult
 from sflkit.analysis.factory import CombinationFactory, analysis_factory_mapping
@@ -15,10 +16,16 @@ from sflkit.model.model import Model
 from sflkit.model.parallel import ParallelModel
 from sflkit.model.scope import Scope
 from sflkit.runners.run import TestResult
-from sflkitlib.events.event import Event
 
 
 class FeatureBuilder(CombinationFactory):
+    def __init__(self):
+        super().__init__(list(map(lambda f: f(), analysis_factory_mapping.values())))
+        self.analysis: dict[EventFile, list[AnalysisObject]] = dict()
+        self.feature_vectors: Dict[EventFile, FeatureVector] = dict()
+        self.all_features: Set[Feature] = set()
+        self.name_map: Dict[EventFile, str] = dict()
+
     def __iter__(self) -> FeatureVector:
         yield from self.feature_vectors.values()
 
@@ -44,22 +51,17 @@ class FeatureBuilder(CombinationFactory):
         if run_id in self.feature_vectors:
             del self.feature_vectors[run_id]
 
-    def __init__(self):
-        super().__init__(list(map(lambda f: f(), analysis_factory_mapping.values())))
-        self.analysis: List[AnalysisObject] = list()
-        self.feature_vectors: Dict[EventFile, FeatureVector] = dict()
-        self.all_features: Set[Feature] = set()
-        self.name_map: Dict[EventFile, str] = dict()
-
     def get_analysis(
         self, event, event_file: EventFile, scope: Scope = None
     ) -> List[AnalysisObject]:
-        self.analysis = super().get_analysis(event, event_file, scope)
-        self.analysis.append(self)
-        return self.analysis
+        self.analysis[event_file] = super().get_analysis(event, event_file, scope)
+        self.analysis[event_file].append(self)
+        return self.analysis[event_file]
 
     @staticmethod
-    def map_evaluation(analysis: Spectrum, id_: EventFile, thread_id: Optional[int] = None):
+    def map_evaluation(
+        analysis: Spectrum, id_: EventFile, thread_id: Optional[int] = None
+    ):
         match analysis.get_last_evaluation(id_, thread_id):
             case EvaluationResult.TRUE:
                 return FeatureValue.TRUE
@@ -73,12 +75,13 @@ class FeatureBuilder(CombinationFactory):
                 return FeatureValue.UNDEFINED
 
     def prepare(self, event_file: EventFile, test_result: TestResult):
+        self.analysis[event_file] = list()
         self.name_map[event_file] = os.path.basename(str(event_file.path))
         self.feature_vectors[event_file] = FeatureVector(event_file, test_result)
 
     # noinspection PyUnusedLocal
     def hit(self, id_: EventFile, event: Event, *args, **kwargs):
-        for a in self.analysis:
+        for a in self.analysis[id_]:
             if isinstance(a, Predicate):
                 feature = TertiaryFeature(str(a), a)
                 self.feature_vectors[id_].set_feature(

{sflkit-0.5.1 → sflkit-0.5.3}/src/sflkit/features/vector.py

@@ -9,7 +9,7 @@ from sflkit.runners.run import TestResult
 class FeatureVector:
     def __init__(
         self,
-        run_id: EventFile,
+        run_id: EventFile | int,
         result: TestResult,
     ):
         self.run_id = run_id

{sflkit-0.5.1 → sflkit-0.5.3}/src/sflkit/model/parallel.py

@@ -42,7 +42,7 @@ class ParallelModel(Model):
             self.returns[event_file].add(
                 event.function, event.return_value, event.type_
             )
-            self.handle_event(event, event_file, self.returns)
+            self.handle_event(event, event_file, self.returns[event_file])
         else:
             self.returns_map[event_file].setdefault(event.thread_id, Scope()).add(
                 event.function, event.return_value, event.type_
@@ -67,10 +67,10 @@ class ParallelModel(Model):
     def handle_def_event(self, event: DefEvent, event_file: EventFile):
         if event.thread_id is None:
             self.variables[event_file].add(event.var, event.value, event.type_)
-            self.handle_event(event, event_file, self.variables)
+            self.handle_event(event, event_file, self.variables[event_file])
         else:
             self.variables_map[event_file].setdefault(
-                event.thread_id, self.variables
+                event.thread_id, self.variables[event_file]
             ).add(event.var, event.value, event.type_)
             self.handle_event(
                 event, event_file, self.variables_map[event_file][event.thread_id]
@@ -83,7 +83,9 @@ class ParallelModel(Model):
             self.handle_event(
                 event,
                 event_file,
-                self.variables_map[event_file].get(event.thread_id, self.variables),
+                self.variables_map[event_file].get(
+                    event.thread_id, self.variables[event_file]
+                ),
             )
 
     def enter_parallel_scope(self, thread_id: int, event_file: EventFile):

{sflkit-0.5.1 → sflkit-0.5.3/src/sflkit.egg-info}/PKG-INFO

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