sflkit 0.5.2__tar.gz → 0.5.4__tar.gz

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

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

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

@@ -85,7 +85,7 @@ class LineFactory(AnalysisFactory):
                 if key not in self.objects:
                     self.objects[key] = Line(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class BranchFactory(AnalysisFactory):
@@ -117,7 +117,7 @@ class BranchFactory(AnalysisFactory):
                 return [self.objects[key], self.objects[else_key]]
             return [self.objects[key]]
 
-        return None
+        return []
 
 
 class FunctionFactory(AnalysisFactory):
@@ -130,7 +130,7 @@ class FunctionFactory(AnalysisFactory):
                 if key not in self.objects:
                     self.objects[key] = Function(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class LoopFactory(AnalysisFactory):
@@ -170,27 +170,70 @@ class LoopFactory(AnalysisFactory):
             elif event.event_type == EventType.LOOP_END:
                 return self.objects[key][:]
             return list()
-        return None
+        return []
 
 
 class DefUseFactory(AnalysisFactory):
     def __init__(self):
         super().__init__()
         self.id_to_def: dict[EventFile, dict[tuple[str, int], DefEvent]] = dict()
+        self.def_stack: dict[EventFile, dict[int, dict[tuple[str, int], DefEvent]]] = (
+            dict()
+        )
 
     def reset(self, event_file: EventFile):
-        with self._lock:
-            self.id_to_def[event_file] = dict()
+        if event_file in self.id_to_def:
+            del self.id_to_def[event_file]
+        if event_file in self.def_stack:
+            del self.def_stack[event_file]
+
+    def _find_def_event(
+        self,
+        event_file: EventFile,
+        scope_id: int,
+        var_name: str,
+        var_id: int,
+    ) -> DefEvent:
+        # Strategy 1: Check in scope
+        def_event = None
+        if event_file in self.def_stack and scope_id in self.def_stack[event_file]:
+            def_event = self.def_stack[event_file][scope_id].get(
+                (var_name, var_id), None
+            )
+
+        # Strategy 2: Look up in the global DEF stack (other threads)
+        if def_event is None:
+            if event_file in self.id_to_def:
+                def_event = self.id_to_def[event_file].get((var_name, var_id), None)
+
+        return def_event
 
     def get_analysis(
         self, event, event_file: EventFile, scope: Scope = None
     ) -> List[AnalysisObject]:
+        thread_id = event.thread_id
+        scope_id = scope.id if scope else 0
+
         if event.event_type == EventType.DEF:
-            with self._lock:
-                self.id_to_def[event_file][(event.var, event.var_id)] = event
+            key = (event.var, event.var_id)
+
+            # Initialize structures if needed
+            if event_file not in self.id_to_def:
+                self.id_to_def[event_file] = dict()
+            if event_file not in self.def_stack:
+                self.def_stack[event_file] = dict()
+            if scope_id not in self.def_stack[event_file]:
+                self.def_stack[event_file][scope_id] = dict()
+
+            # Store the DEF event
+            self.id_to_def[event_file][key] = event
+            self.def_stack[event_file][scope_id][key] = event
+
         elif event.event_type == EventType.USE:
-            with self._lock:
-                def_event = self.id_to_def[event_file].get((event.var, event.var_id))
+            def_event = self._find_def_event(
+                event_file, scope_id, event.var, event.var_id
+            )
+
             if def_event:
                 key = (
                     DefUse.analysis_type(),
@@ -204,7 +247,7 @@ class DefUseFactory(AnalysisFactory):
                     if key not in self.objects:
                         self.objects[key] = DefUse(def_event, event)
                 return [self.objects[key]]
-        return None
+        return []
 
 
 class ConditionFactory(AnalysisFactory):
@@ -267,24 +310,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_:
@@ -306,7 +348,7 @@ class ScalarPairFactory(ComparisonFactory):
                                         )
                                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class VariableFactory(ComparisonFactory):
@@ -333,7 +375,7 @@ class VariableFactory(ComparisonFactory):
                         self.objects[key] = VariablePredicate(event, comp)
                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class ReturnFactory(ComparisonFactory):
@@ -403,7 +445,7 @@ class ReturnFactory(ComparisonFactory):
                                 )
                         objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class ConstantCompFactory(AnalysisFactory):
@@ -430,7 +472,7 @@ class ConstantCompFactory(AnalysisFactory):
                         self.objects[key] = self.class_(event)
                 objects.append(self.objects[key])
             return objects
-        return None
+        return []
 
 
 class NoneFactory(ConstantCompFactory):
@@ -468,7 +510,7 @@ class PredicateFunctionFactory(AnalysisFactory):
                     # noinspection PyArgumentList
                     self.objects[key] = self.class_(event)
             return [self.objects[key]]
-        return None
+        return []
 
 
 class IsAsciiFactory(PredicateFunctionFactory):
@@ -519,7 +561,7 @@ class LengthFactory(AnalysisFactory):
                             Length(event, Length.evaluate_length_more)
                         )
             return self.objects[key][:]
-        return None
+        return []
 
 
 class FunctionErrorFactory(AnalysisFactory):
@@ -531,11 +573,9 @@ class FunctionErrorFactory(AnalysisFactory):
         self, event, event_file: EventFile, scope: Scope = None
     ) -> List[AnalysisObject]:
         if event.event_type == EventType.FUNCTION_ENTER:
-            with self._lock:
-                self.function_mapping[event.function_id] = event.line
+            self.function_mapping[event.function_id] = event.line
         if event.event_type in (EventType.FUNCTION_ERROR, EventType.FUNCTION_EXIT):
-            with self._lock:
-                line = self.function_mapping.get(event.function_id, event.line)
+            line = self.function_mapping.get(event.function_id, event.line)
             key = (
                 FunctionErrorPredicate.analysis_type(),
                 event.file,
@@ -548,7 +588,7 @@ class FunctionErrorFactory(AnalysisFactory):
                         event.file, line, event.function
                     )
             return [self.objects[key]]
-        return None
+        return []
 
 
 analysis_factory_mapping = {

{sflkit-0.5.2 → sflkit-0.5.4}/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.2 → sflkit-0.5.4}/src/sflkit/language/meta.py

@@ -1,5 +1,6 @@
 import random
 from abc import ABC
+from threading import Lock
 from typing import List, Type, Any
 
 from sflkitlib.events.event import Event
@@ -60,10 +61,12 @@ class Injection:
 class IDGenerator:
     def __init__(self):
         self.current_id = 0
+        self.lock = Lock()
 
     def get_next_id(self):
-        id_ = self.current_id
-        self.current_id += 1
+        with self.lock:
+            id_ = self.current_id
+            self.current_id += 1
         return id_
 
 

{sflkit-0.5.2 → sflkit-0.5.4}/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.4/src/sflkit/model/scope.py

@@ -0,0 +1,82 @@
+from threading import Lock
+from typing import List
+
+
+class Var(object):
+    def __init__(self, var, value, type_, id_: int = None):
+        self.var = var
+        self.value = value
+        self.type_ = type_
+        self.id = id_ if id_ is not None else hash(self)
+
+    def __hash__(self):
+        return hash(self.var)
+
+    def __eq__(self, other):
+        return isinstance(other, Var) and self.var == other.var
+
+
+class IDGenerator:
+    def __init__(self):
+        self.current_id = 0
+        self.lock = Lock()
+
+    def get_next_id(self):
+        with self.lock:
+            self.current_id += 1
+            return self.current_id
+
+
+class Scope(object):
+
+    SCOPE_ID = IDGenerator()
+
+    def __init__(self, parent=None):
+        self.parent = parent
+        self.variables = dict()
+        self.id = Scope.SCOPE_ID.get_next_id()
+
+    def __hash__(self):
+        return hash(self.id)
+
+    def __eq__(self, other):
+        return isinstance(other, Scope) and self.id == other.id
+
+    def enter(self):
+        return Scope(parent=self)
+
+    def exit(self):
+        if self.parent is not None:
+            return self.parent
+        else:
+            return self
+
+    def __contains__(self, var: str) -> bool:
+        current = self
+        while current is not None:
+            if var in current.variables:
+                return True
+            current = current.parent
+        return False
+
+    def value(self, var: str) -> Var:
+        current = self
+        while current is not None:
+            if var in current.variables:
+                return current.variables[var].value
+            current = current.parent
+        return None
+
+    def add(self, var, value, type_, id_: int = None):
+        self.variables[var] = Var(var, value, type_, id_)
+
+    def get_all_vars_dict(self):
+        current = self
+        variables = dict()
+        while current is not None:
+            variables = {**current.variables, **variables}
+            current = current.parent
+        return variables
+
+    def get_all_vars(self) -> List[Var]:
+        return list(self.get_all_vars_dict().values())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sflkit
-Version: 0.5.2
+Version: 0.5.4
 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.4/tests/test_scope.py

@@ -0,0 +1,43 @@
+import unittest
+
+from sflkit.model.scope import Var, Scope
+
+
+class TestScope(unittest.TestCase):
+    def test_var_eq(self):
+        var_1 = Var("x", 2, int)
+        var_2 = Var("y", 2, int)
+        var_3 = Var("x", "", str)
+        self.assertEqual(var_1, var_3)
+        self.assertNotEqual(var_1, var_2)
+        self.assertNotEqual(var_2, var_3)
+        self.assertEqual(hash(var_1), hash(var_3))
+        self.assertNotEqual(hash(var_1), hash(var_2))
+        self.assertNotEqual(hash(var_2), hash(var_3))
+
+    def test_scope_without_parent(self):
+        scope = Scope()
+        self.assertIs(scope, scope.exit())
+
+    def test_scope_with_parent(self):
+        parent_scope = Scope()
+        child_scope = parent_scope.enter()
+        self.assertIs(parent_scope, child_scope.exit())
+
+    def test_scope_contains(self):
+        scope = Scope()
+        scope.variables["x"] = Var("x", 10, int)
+        self.assertIn("x", scope)
+        self.assertNotIn("y", scope)
+
+    def test_scope_all_vars(self):
+        parent_scope = Scope()
+        parent_scope.variables["x"] = Var("x", 10, int)
+        child_scope = parent_scope.enter()
+        child_scope.variables["y"] = Var("y", 20, int)
+
+        all_vars = child_scope.get_all_vars_dict()
+        self.assertIn("x", all_vars)
+        self.assertIn("y", all_vars)
+        self.assertEqual(all_vars["x"].value, 10)
+        self.assertEqual(all_vars["y"].value, 20)

sflkit-0.5.2/src/sflkit/model/scope.py

@@ -1,39 +0,0 @@
-from typing import List
-
-
-class Var(object):
-    def __init__(self, var, value, type_):
-        self.var = var
-        self.value = value
-        self.type_ = type_
-
-    def __hash__(self):
-        return hash(self.var)
-
-    def __eq__(self, other):
-        return isinstance(other, Var) and self.var == other.var
-
-
-class Scope(object):
-    def __init__(self, parent=None, variables: dict = None):
-        self.parent = parent
-        self.variables = dict() if variables is None else variables.copy()
-
-    def enter(self):
-        return Scope(parent=self, variables=self.variables)
-
-    def exit(self):
-        if self.parent is not None:
-            return self.parent
-        else:
-            return self
-
-    def value(self, var: str) -> Var:
-        if var in self.variables:
-            return self.variables[var].value
-
-    def add(self, var, value, type_):
-        self.variables[var] = Var(var, value, type_)
-
-    def get_all_vars(self) -> List[Var]:
-        return list(self.variables.values())

sflkit-0.5.2/tests/test_scope.py

@@ -1,20 +0,0 @@
-import unittest
-
-from sflkit.model.scope import Var, Scope
-
-
-class TestScope(unittest.TestCase):
-    def test_var_eq(self):
-        var_1 = Var("x", 2, int)
-        var_2 = Var("y", 2, int)
-        var_3 = Var("x", "", str)
-        self.assertEqual(var_1, var_3)
-        self.assertNotEqual(var_1, var_2)
-        self.assertNotEqual(var_2, var_3)
-        self.assertEqual(hash(var_1), hash(var_3))
-        self.assertNotEqual(hash(var_1), hash(var_2))
-        self.assertNotEqual(hash(var_2), hash(var_3))
-
-    def test_scope_without_parent(self):
-        scope = Scope()
-        self.assertIs(scope, scope.exit())