sflkit 0.5.1__tar.gz → 0.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.1
+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/

{sflkit-0.5.1 → 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.1"
+__version__ = "0.5.2"
 
 
 def instrument_config(conf: Config):

{sflkit-0.5.1 → sflkit-0.5.2}/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
 
@@ -365,8 +367,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 +396,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 +531,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.2}/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.2}/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.2/src/sflkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.1
+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/