sflkit 0.2.22__tar.gz → 0.3.1__tar.gz

{sflkit-0.2.22 → sflkit-0.3.1}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Andreas Zeller's group at CISPA and Saarland University
+Copyright (c) 2022 Marius Smytzek
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{sflkit-0.2.22/src/sflkit.egg-info → sflkit-0.3.1}/PKG-INFO

@@ -1,10 +1,31 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sflkit
-Version: 0.2.22
+Version: 0.3.1
 Summary: SFLKit: : A Workbench for Statistical Fault Localization
-Author-email: Marius Smytzek <marius.smytzek@cispa.de>
-Project-URL: Homepage, https://github.com/uds-se/sflkit/
-Project-URL: Bug Tracker, https://github.com/uds-se/sflkit/issues
+License: MIT License
+        
+        Copyright (c) 2022 Marius Smytzek
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/smythi93/sflkit/
+Project-URL: Bug Tracker, https://github.com/smythi93/sflkit/issues
 Classifier: Intended Audience :: Science/Research
 Classifier: Programming Language :: Python :: 3.10
 Classifier: License :: OSI Approved :: MIT License
@@ -13,25 +34,27 @@ Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sflkitlib>=0.0.5
-Requires-Dist: numpy>=1.23.5
-Requires-Dist: matplotlib>=3.7.2
+Requires-Dist: sflkitlib>=0.0.6
+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
 Provides-Extra: test
-Requires-Dist: pytest>=7.2.2; extra == "test"
-Requires-Dist: pytest-cov>=4.1.0; extra == "test"
-Requires-Dist: pytest-html>=3.2.0; extra == "test"
-Requires-Dist: pytest-rerunfailures>=11.1.2; extra == "test"
-Requires-Dist: parameterized>=0.8.1; extra == "test"
+Requires-Dist: pytest>=8.3.4; extra == "test"
+Requires-Dist: pytest-cov>=6.0.0; extra == "test"
+Requires-Dist: pytest-html>=4.1.1; extra == "test"
+Requires-Dist: pytest-rerunfailures>=15.0; extra == "test"
+Requires-Dist: parameterized>=0.9.0; extra == "test"
 
 # SFLKit: A Workbench for Statistical Fault Localization
 
 [![Python Version](https://img.shields.io/pypi/pyversions/sflkit)](https://pypi.org/project/sflkit/)
-[![GitHub release](https://img.shields.io/github/v/release/uds-se/sflkit)](https://github.com/uds-se/sflkit/releases)
+[![GitHub release](https://img.shields.io/github/v/release/smythi93/sflkit)](https://github.com/smythi93/sflkit/releases)
 [![PyPI](https://img.shields.io/pypi/v/sflkit)](https://pypi.org/project/sflkit/)
-[![Build Status](https://img.shields.io/github/actions/workflow/status/uds-se/sflkit/test-sflkit.yml?branch=main)](https://img.shields.io/github/actions/workflow/status/uds-se/sflkit/test-sflkit.yml?branch=main)
-[![Coverage Status](https://coveralls.io/repos/github/uds-se/sflkit/badge.svg?branch=main)](https://coveralls.io/github/uds-se/sflkit?branch=main)
-[![Licence](https://img.shields.io/github/license/uds-se/sflkit)](https://img.shields.io/github/license/uds-se/sflkit)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/smythi93/sflkit/test-sflkit.yml?branch=main)](https://img.shields.io/github/actions/workflow/status/smythi93/sflkit/test-sflkit.yml?branch=main)
+[![Coverage Status](https://coveralls.io/repos/github/smythi93/sflkit/badge.svg?branch=main)](https://coveralls.io/github/smythi93/sflkit?branch=main)
+[![Licence](https://img.shields.io/github/license/smythi93/sflkit)](https://img.shields.io/github/license/smythi93/sflkit)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 SFLKit (https://dl.acm.org/doi/10.1145/3540250.3558915) is an out-of-the-box library and tool for statistical fault 

{sflkit-0.2.22 → sflkit-0.3.1}/README.md

@@ -1,11 +1,11 @@
 # SFLKit: A Workbench for Statistical Fault Localization
 
 [![Python Version](https://img.shields.io/pypi/pyversions/sflkit)](https://pypi.org/project/sflkit/)
-[![GitHub release](https://img.shields.io/github/v/release/uds-se/sflkit)](https://github.com/uds-se/sflkit/releases)
+[![GitHub release](https://img.shields.io/github/v/release/smythi93/sflkit)](https://github.com/smythi93/sflkit/releases)
 [![PyPI](https://img.shields.io/pypi/v/sflkit)](https://pypi.org/project/sflkit/)
-[![Build Status](https://img.shields.io/github/actions/workflow/status/uds-se/sflkit/test-sflkit.yml?branch=main)](https://img.shields.io/github/actions/workflow/status/uds-se/sflkit/test-sflkit.yml?branch=main)
-[![Coverage Status](https://coveralls.io/repos/github/uds-se/sflkit/badge.svg?branch=main)](https://coveralls.io/github/uds-se/sflkit?branch=main)
-[![Licence](https://img.shields.io/github/license/uds-se/sflkit)](https://img.shields.io/github/license/uds-se/sflkit)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/smythi93/sflkit/test-sflkit.yml?branch=main)](https://img.shields.io/github/actions/workflow/status/smythi93/sflkit/test-sflkit.yml?branch=main)
+[![Coverage Status](https://coveralls.io/repos/github/smythi93/sflkit/badge.svg?branch=main)](https://coveralls.io/github/smythi93/sflkit?branch=main)
+[![Licence](https://img.shields.io/github/license/smythi93/sflkit)](https://img.shields.io/github/license/smythi93/sflkit)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 
 SFLKit (https://dl.acm.org/doi/10.1145/3540250.3558915) is an out-of-the-box library and tool for statistical fault 

{sflkit-0.2.22 → sflkit-0.3.1}/pyproject.toml

@@ -1,19 +1,16 @@
 [build-system]
 requires = [
-    "setuptools>=67.6.0",
+    "setuptools>=75.8.0",
     "wheel"
 ]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "sflkit"
-version = "0.2.22"
-authors = [
-    { name = "Marius Smytzek", email = "marius.smytzek@cispa.de" },
-]
+version = "0.3.1"
 description = "SFLKit: : A Workbench for Statistical Fault Localization"
 readme = "README.md"
-license = { file = "COPYING" }
+license = { file = "LICENSE" }
 requires-python = ">=3.10"
 classifiers = [
     "Intended Audience :: Science/Research",
@@ -23,26 +20,28 @@ classifiers = [
     "Topic :: Software Development :: Testing"
 ]
 dependencies = [
-    "sflkitlib>=0.0.5",
-    "numpy>=1.23.5",
-    "matplotlib>=3.7.2",
-    "sortedcollections>=2.1.0"
+    "sflkitlib>=0.0.6",
+    "numpy>=2.1.3",
+    "matplotlib>=3.10.0",
+    "pandas>=2.2.3",
+    "sortedcollections>=2.1.0",
+    "java-ast>=1.0.2",
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/uds-se/sflkit/"
-"Bug Tracker" = "https://github.com/uds-se/sflkit/issues"
+"Homepage" = "https://github.com/smythi93/sflkit/"
+"Bug Tracker" = "https://github.com/smythi93/sflkit/issues"
 
 [project.scripts]
 sflkit = "sflkit.cli:main"
 
 [project.optional-dependencies]
 test = [
-    "pytest>=7.2.2",
-    "pytest-cov>=4.1.0",
-    "pytest-html>=3.2.0",
-    "pytest-rerunfailures>=11.1.2",
-    "parameterized>=0.8.1"
+    "pytest>=8.3.4",
+    "pytest-cov>=6.0.0",
+    "pytest-html>=4.1.1",
+    "pytest-rerunfailures>=15.0",
+    "parameterized>=0.9.0"
 ]
 
 [tool.black]

{sflkit-0.2.22 → sflkit-0.3.1}/src/sflkit/__init__.py

@@ -2,19 +2,22 @@ from os import PathLike
 from pathlib import Path
 
 from sflkit.analysis.analyzer import Analyzer
-from sflkit.analysis.predicate import Predicate
 from sflkit.config import Config, parse_config
 from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
 
 def instrument_config(conf: Config):
-    instrumentation = DirInstrumentation(conf.visitor, conf.mapping.path)
+    instrumentation = DirInstrumentation(
+        conf.visitor, conf.mapping.path, test_visitor=conf.test_visitor
+    )
     instrumentation.instrument(
         conf.target_path,
         conf.instrument_working,
         suffixes=conf.language.suffixes,
         includes=conf.instrument_include,
         excludes=conf.instrument_exclude,
+        tests=conf.instrument_test,
+        test_files=conf.instrument_test_files,
     )
     instrumentation.dump_events(conf)
 

{sflkit-0.2.22 → sflkit-0.3.1}/src/sflkit/analysis/analysis_type.py

@@ -1,7 +1,8 @@
 import enum
 from abc import abstractmethod
-from typing import List, Type
+from typing import List, Type, Optional
 
+from sflkit.events.event_file import EventFile
 from sflkit.model.scope import Scope
 
 
@@ -42,7 +43,7 @@ If you want to add new spectra or predicates, please register them here and in s
 """
 
 
-class AnalysisObject(object):
+class AnalysisObject:
     function_finder = None
     loop_finder = None
     branch_finder = None
@@ -54,11 +55,23 @@ class AnalysisObject(object):
         AnalysisObject.branch_finder = branch_finder
 
     # noinspection PyUnusedLocal
-    def __init__(self, event):
+    def __init__(self):
         self.suspiciousness: float = 0
         self.last_evaluation: EvaluationResult = EvaluationResult.UNOBSERVED
         self.hits = dict()
 
+    def adjust_weight(self, event_file: EventFile, weight: float):
+        pass
+
+    @abstractmethod
+    def serialize(self) -> dict:
+        pass
+
+    @staticmethod
+    @abstractmethod
+    def deserialize(s: dict) -> "AnalysisObject":
+        pass
+
     def get_last_evaluation(self, id_: int) -> EvaluationResult:
         return self.last_evaluation
 
@@ -136,3 +149,21 @@ class AnalysisObject(object):
             return self.suspiciousness <= other
         else:
             raise TypeError(f"<= supported between {type(self)} and {type(other)}")
+
+
+class MetaEvent:
+    def __init__(
+        self,
+        file: str,
+        line: int,
+        function: Optional[str] = None,
+        var: Optional[str] = None,
+        then_id: Optional[int] = None,
+        else_id: Optional[int] = None,
+    ):
+        self.file = file
+        self.line = line
+        self.function = function
+        self.var = var
+        self.then_id = then_id
+        self.else_id = else_id

sflkit-0.3.1/src/sflkit/analysis/analyzer.py

@@ -0,0 +1,227 @@
+import json
+import os
+from typing import List, Callable, Set, Dict, Optional, Any, Type
+
+from sflkit.analysis.analysis_type import AnalysisType, AnalysisObject
+from sflkit.analysis.factory import AnalysisFactory
+from sflkit.analysis.predicate import (
+    Branch,
+    ScalarPair,
+    VariablePredicate,
+    NonePredicate,
+    ReturnPredicate,
+    EmptyStringPredicate,
+    EmptyBytesPredicate,
+    IsAsciiPredicate,
+    ContainsDigitPredicate,
+    ContainsSpecialPredicate,
+    Condition,
+    FunctionErrorPredicate,
+)
+from sflkit.analysis.spectra import Line, Function, DefUse, Loop, Length
+from sflkit.analysis.suggestion import Suggestion
+from sflkit.events.event_file import EventFile
+from sflkit.model.model import Model, MetaModel
+
+
+class AnalysisEncoder(json.JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if isinstance(o, AnalysisObject):
+            return o.serialize()
+        else:
+            super().default(o)
+
+
+class Analyzer:
+    def __init__(
+        self,
+        relevant_event_files: Optional[List[EventFile]] = None,
+        irrelevant_event_files: Optional[List[EventFile]] = None,
+        factory: Optional[AnalysisFactory] = None,
+        meta_model: Optional[MetaModel] = None,
+        model_class: Type[Model] = Model,
+    ):
+        if (
+            relevant_event_files is None
+            or irrelevant_event_files is None
+            or factory is None
+        ):
+            if meta_model is None:
+                raise ValueError("meta_model must be provided")
+            self.meta = True
+        else:
+            self.meta = False
+        self.relevant_event_files = relevant_event_files
+        self.irrelevant_event_files = irrelevant_event_files
+        if self.meta:
+            self.model = meta_model
+        else:
+            self.model = model_class(factory)
+        self.paths: Dict[int, os.PathLike] = dict()
+        self.max_suspiciousness = 0
+        self.min_suspiciousness = 0
+        self.mean_suspiciousness = 0
+        self.median_suspiciousness = 0
+
+    def _analyze(self, event_file):
+        if self.meta:
+            raise NotImplementedError("Not implemented for meta/loaded analyzer")
+        self.model.prepare(event_file)
+        with event_file:
+            for event in event_file.load():
+                event.handle(self.model)
+        self.model.follow_up(event_file)
+
+    def _finalize(self):
+        if self.meta:
+            raise NotImplementedError("Not implemented for meta/loaded analyzer")
+        self.model.finalize(self.irrelevant_event_files, self.relevant_event_files)
+
+    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)
+        self._finalize()
+
+    def dump(self, path: os.PathLike, indent: Optional[int] = None):
+        with open(path, "w") as f:
+            json.dump(self.get_analysis(), f, cls=AnalysisEncoder, indent=indent)
+
+    def dumps(self, indent: Optional[int] = None):
+        return json.dumps(self.get_analysis(), cls=AnalysisEncoder, indent=indent)
+
+    @staticmethod
+    def load(path: os.PathLike):
+        return Analyzer(meta_model=MetaModel(load_analysis_json(path)))
+
+    @staticmethod
+    def loads(data: str):
+        return Analyzer(meta_model=MetaModel(set(map(deserialize, json.loads(data)))))
+
+    def get_analysis(self) -> Set[AnalysisObject]:
+        return list(self.model.get_analysis())
+
+    def get_analysis_by_type(self, type_: AnalysisType) -> Set[AnalysisObject]:
+        return list(
+            filter(lambda p: p.analysis_type() == type_, self.model.get_analysis())
+        )
+
+    def get_sorted_suggestions(
+        self,
+        base_dir,
+        metric: Callable = None,
+        type_: AnalysisType = None,
+        use_weight: bool = False,
+    ) -> List[Suggestion]:
+        if type_:
+            objects = self.get_analysis_by_type(type_)
+        else:
+            objects = self.get_analysis()
+        return self.get_sorted_suggestions_from_analysis(
+            base_dir, objects, metric, use_weight=use_weight
+        )
+
+    def get_sorted_suggestions_from_analysis(
+        self,
+        base_dir,
+        analysis: Set[AnalysisObject],
+        metric: Callable = None,
+        use_weight: bool = False,
+    ) -> List[Suggestion]:
+        suggestions = dict()
+        suspiciousness = list()
+        for suggestion in map(
+            lambda p: p.get_suggestion(
+                metric=metric, base_dir=base_dir, use_weight=use_weight
+            ),
+            analysis,
+        ):
+            suspiciousness.append(suggestion.suspiciousness)
+            if suggestion.suspiciousness not in suggestions:
+                suggestions[suggestion.suspiciousness] = set(suggestion.lines)
+            else:
+                suggestions[suggestion.suspiciousness] |= set(suggestion.lines)
+
+        if suspiciousness:
+            self.max_suspiciousness = max(suspiciousness)
+            self.min_suspiciousness = min(suspiciousness)
+            self.mean_suspiciousness = sum(suspiciousness) / len(suspiciousness)
+            self.median_suspiciousness = sorted(suspiciousness)[
+                len(suspiciousness) // 2
+            ]
+
+        return sorted(
+            [
+                Suggestion(list(lines), suspiciousness)
+                for suspiciousness, lines in suggestions.items()
+            ],
+            reverse=True,
+        )[:]
+
+    def get_coverage_per_run(
+        self, type_: AnalysisType = None
+    ) -> Dict[EventFile, Set[AnalysisObject]]:
+        if type_:
+            objects = self.get_analysis_by_type(type_)
+        else:
+            objects = self.get_analysis()
+        coverage = dict()
+        for obj in objects:
+            for event_file in obj.hits:
+                if event_file not in coverage:
+                    coverage[event_file] = {obj}
+                else:
+                    coverage[event_file].add(obj)
+        return coverage
+
+    def get_coverage(self, type_: AnalysisType = None) -> Set[AnalysisObject]:
+        coverage = self.get_coverage_per_run(type_)
+        return set.union(*coverage.values())
+
+
+def deserialize(analysis_object: dict) -> AnalysisObject:
+    analysis_type = AnalysisType(analysis_object["type"])
+    if analysis_type == AnalysisType.LINE:
+        return Line.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.FUNCTION:
+        return Function.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.DEF_USE:
+        return DefUse.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.LOOP:
+        return Loop.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.LENGTH:
+        return Length.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.BRANCH:
+        return Branch.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.SCALAR_PAIR:
+        return ScalarPair.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.VARIABLE:
+        return VariablePredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.RETURN:
+        return ReturnPredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.NONE:
+        return NonePredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.EMPTY_STRING:
+        return EmptyStringPredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.EMPTY_BYTES:
+        return EmptyBytesPredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.ASCII_STRING:
+        return IsAsciiPredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.DIGIT_STRING:
+        return ContainsDigitPredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.SPECIAL_STRING:
+        return ContainsSpecialPredicate.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.CONDITION:
+        return Condition.deserialize(analysis_object)
+    elif analysis_type == AnalysisType.FUNCTION_ERROR:
+        return FunctionErrorPredicate.deserialize(analysis_object)
+    else:
+        raise ValueError(f"Unknown analysis type {analysis_type}")
+
+
+def load_analysis_json(path):
+    with open(path, "r") as f:
+        data = json.load(f)
+    return set(map(deserialize, data))

{sflkit-0.2.22 → sflkit-0.3.1}/src/sflkit/analysis/factory.py

@@ -153,29 +153,42 @@ class DefUseFactory(AnalysisFactory):
 
     def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
         if event.event_type == EventType.DEF:
-            self.id_to_def[event.var_id] = event
+            self.id_to_def[(event.var, event.var_id)] = event
         elif event.event_type == EventType.USE:
-            if event.var_id in self.id_to_def:
+            if (event.var, event.var_id) in self.id_to_def:
                 key = (
                     DefUse.analysis_type(),
-                    self.id_to_def[event.var_id].file,
-                    self.id_to_def[event.var_id].line,
+                    self.id_to_def[(event.var, event.var_id)].file,
+                    self.id_to_def[(event.var, event.var_id)].line,
                     event.file,
                     event.line,
                     event.var,
                 )
                 if key not in self.objects:
-                    self.objects[key] = DefUse(self.id_to_def[event.var_id], event)
+                    self.objects[key] = DefUse(
+                        self.id_to_def[(event.var, event.var_id)], event
+                    )
                 return [self.objects[key]]
 
 
 class ConditionFactory(AnalysisFactory):
     def get_analysis(self, event, scope: Scope = None) -> List[AnalysisObject]:
+        objects = list()
         if event.event_type == EventType.CONDITION:
-            key = (Condition.analysis_type(), event.file, event.line, event.condition)
-            if key not in self.objects:
-                self.objects[key] = Condition(event.file, event.line, event.condition)
-            return [self.objects[key]]
+            for negate in (True, False):
+                key = (
+                    Condition.analysis_type(),
+                    event.file,
+                    event.line,
+                    event.condition,
+                    negate,
+                )
+                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
 
 
 class ComparisonFactory(AnalysisFactory, abc.ABC):
@@ -439,7 +452,7 @@ class FunctionErrorFactory(AnalysisFactory):
         if event.event_type == EventType.FUNCTION_ENTER:
             self.function_mapping[event.function_id] = event.line
         if event.event_type in (EventType.FUNCTION_ERROR, EventType.FUNCTION_EXIT):
-            line = self.function_mapping[event.function_id]
+            line = self.function_mapping.get(event.function_id, event.line)
             key = (
                 FunctionErrorPredicate.analysis_type(),
                 event.file,