sflkit 0.2.17__tar.gz → 0.2.19__tar.gz

{sflkit-0.2.17/src/sflkit.egg-info → sflkit-0.2.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sflkit
-Version: 0.2.17
+Version: 0.2.19
 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/

{sflkit-0.2.17 → sflkit-0.2.19}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sflkit"
-version = "0.2.17"
+version = "0.2.19"
 authors = [
     { name = "Marius Smytzek", email = "marius.smytzek@cispa.de" },
 ]

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit/__init__.py

@@ -8,7 +8,7 @@ from sflkit.instrumentation.dir_instrumentation import DirInstrumentation
 
 
 def instrument_config(conf: Config):
-    instrumentation = DirInstrumentation(conf.visitor)
+    instrumentation = DirInstrumentation(conf.visitor, conf.mapping.path)
     instrumentation.instrument(
         conf.target_path,
         conf.instrument_working,

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit/config.py

@@ -77,6 +77,7 @@ class Config:
         self.instrument_working = None
         self.runner = None
         self.mapping = None
+        self.mapping_path = None
         if path:
             if isinstance(path, configparser.ConfigParser):
                 config = path
@@ -143,10 +144,12 @@ class Config:
                     self.metrics = [Spectrum.Ochiai]
 
                 run_id_generator = IDGenerator()
+                if "mapping" in events:
+                    self.mapping_path = Path(events["mapping"])
                 try:
                     self.mapping = EventMapping.load(self)
                 except InstrumentationError:
-                    self.mapping = EventMapping()
+                    self.mapping = EventMapping(path=self.mapping_path)
                 if "passing" in events:
                     self.passing = self.get_event_files(
                         list(csv.reader([events["passing"]]))[0],
@@ -198,6 +201,7 @@ class Config:
         visitor: ASTVisitor = None,
         passing: List[EventFile] = None,
         failing: List[EventFile] = None,
+        mapping: EventMapping = None,
         instrument_include: List[str] = None,
         instrument_exclude: List[str] = None,
         instrument_working: str = None,
@@ -220,6 +224,10 @@ class Config:
         conf.instrument_exclude = instrument_exclude if instrument_exclude else list()
         conf.instrument_working = instrument_working
         conf.runner = runner
+        if mapping:
+            conf.mapping = mapping
+            if mapping.path:
+                conf.mapping_path = mapping.path
         return conf
 
     @staticmethod
@@ -263,6 +271,7 @@ class Config:
         metrics=None,
         passing=None,
         failing=None,
+        mapping_path=None,
         working=None,
         include=None,
         exclude=None,
@@ -288,6 +297,8 @@ class Config:
             conf["events"]["passing"] = passing
         if failing:
             conf["events"]["failing"] = failing
+        if mapping_path:
+            conf["events"]["mapping"] = mapping_path
         if working:
             conf["instrumentation"]["path"] = working
         if include:
@@ -320,6 +331,8 @@ class Config:
             conf["events"]["passing"] = ",".join(e.path for e in self.passing)
         if self.failing:
             conf["events"]["failing"] = ",".join(e.path for e in self.failing)
+        if self.mapping_path:
+            conf["events"]["mapping"] = str(self.mapping_path)
         if self.instrument_working:
             conf["instrumentation"]["path"] = str(self.instrument_working)
         if self.instrument_include:

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit/instrumentation/__init__.py

@@ -1,8 +1,6 @@
-import json
 from abc import abstractmethod
-from typing import List
-
-from sflkitlib.events import event
+from pathlib import Path
+from typing import List, Optional
 
 from sflkit import Config
 from sflkit.language.visitor import ASTVisitor
@@ -10,9 +8,9 @@ from sflkit.mapping import EventMapping
 
 
 class Instrumentation:
-    def __init__(self, visitor: ASTVisitor):
+    def __init__(self, visitor: ASTVisitor, mapping_path: Optional[Path] = None):
         self.visitor = visitor
-        self.events = EventMapping()
+        self.events = EventMapping(path=mapping_path)
 
     @abstractmethod
     def instrument(

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit/instrumentation/dir_instrumentation.py

@@ -2,6 +2,7 @@ import os
 import queue
 import re
 import shutil
+from pathlib import Path
 from typing import List, Optional, Iterable, Tuple
 
 from sflkit.instrumentation import Instrumentation
@@ -11,9 +12,9 @@ from sflkit.logger import LOGGER
 
 
 class DirInstrumentation(Instrumentation):
-    def __init__(self, visitor: ASTVisitor):
-        super().__init__(visitor)
-        self.file_instrumentation = FileInstrumentation(visitor)
+    def __init__(self, visitor: ASTVisitor, mapping_path: Optional[Path] = None):
+        super().__init__(visitor, mapping_path)
+        self.file_instrumentation = FileInstrumentation(visitor, mapping_path)
 
     @staticmethod
     def check_included(element: str, includes: Optional[Iterable[str]]):

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit/instrumentation/file_instrumentation.py

@@ -1,4 +1,5 @@
-from typing import List
+from pathlib import Path
+from typing import List, Optional
 
 from sflkit.instrumentation import Instrumentation
 from sflkit.language.visitor import ASTVisitor
@@ -6,13 +7,13 @@ from sflkit.mapping import EventMapping
 
 
 class FileInstrumentation(Instrumentation):
-    def __init__(self, visitor: ASTVisitor):
-        super().__init__(visitor)
+    def __init__(self, visitor: ASTVisitor, mapping_path: Optional[Path] = None):
+        super().__init__(visitor, mapping_path)
 
     def instrument(
         self, src: str, dst: str, suffixes: List[str] = None, file: str = ""
     ):
         self.visitor.instrument(src, dst, file)
         self.events = EventMapping(
-            {event.event_id: event for event in self.visitor.events}
+            {event.event_id: event for event in self.visitor.events}, self.events.path
         )

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit/mapping.py

@@ -13,37 +13,45 @@ class InstrumentationError(RuntimeError):
 
 
 class EventMapping:
-    def __init__(self, mapping: Dict[int, Event] = None):
+    def __init__(
+        self, mapping: Dict[int, Event] = None, path: Optional[os.PathLike] = None
+    ):
         self.mapping = mapping or dict()
+        self.path = path
 
     def get(self, event_id) -> Optional[Event]:
         return self.mapping.get(event_id, None)
 
     @staticmethod
-    def get_path(identifier: str):
+    def get_path(identifier: str) -> Path:
         return SFLKIT_PATH / f"{identifier}.json"
 
     @staticmethod
     def load(config: Any):
         if not hasattr(config, "identifier"):
             raise InstrumentationError(f"Argument does not have an identifier")
-        return EventMapping.load_from_file(config.identifier())
+        return EventMapping.load_from_file(
+            config.mapping_path or EventMapping.get_path(config.identifier()),
+            config.target_path,
+        )
 
     @staticmethod
-    def load_from_file(identifier: str):
-        file = EventMapping.get_path(identifier)
+    def load_from_file(file: Path, path: os.PathLike):
         if file.exists():
-            return EventMapping(load_json(file))
+            return EventMapping(load_json(file), file)
         else:
             raise InstrumentationError(
-                f"Cannot find information about instrumentation of {identifier or file}"
+                f"Cannot find information about instrumentation of {path or file}"
             )
 
     def write(self, config):
         if not hasattr(config, "identifier"):
             raise InstrumentationError(f"Argument does not have an identifier")
-        SFLKIT_PATH.mkdir(parents=True, exist_ok=True)
-        file = self.get_path(config.identifier())
+        if self.path:
+            file = self.path
+        else:
+            SFLKIT_PATH.mkdir(parents=True, exist_ok=True)
+            file = self.get_path(config.identifier())
         with file.open("w") as fp:
             json.dump(list(self.mapping.values()), fp, cls=EventEncoder)
 

sflkit-0.2.19/src/sflkit/runners/resources/pytest_main.py

@@ -0,0 +1,82 @@
+import os
+import sys
+from typing import Optional, Union, List, Sequence
+
+# noinspection PyPackageRequirements
+from _pytest._code import ExceptionInfo
+
+# noinspection PyPackageRequirements
+from _pytest._io import TerminalWriter
+
+# noinspection PyPackageRequirements
+from _pytest.config import (
+    ExitCode,
+    _prepareconfig,
+    ConftestImportFailure,
+    UsageError,
+    filter_traceback_for_conftest_import_failure,
+    _PluggyPlugin,
+)
+
+
+def pytest_collection_finish(session):
+    """
+    Called after collection has been performed and modified.
+    """
+    file = os.getenv("SFLKIT_PYTEST_COLLECTION_FINISH_FILE", "tmp_sflkit_pytest")
+    with open(file, "w") as f:
+        for item in session.items:
+            f.write(item.nodeid + "\n")
+
+
+def main(
+    args: Optional[Union[List[str], "os.PathLike[str]"]] = None,
+    plugins: Optional[Sequence[Union[str, _PluggyPlugin]]] = None,
+) -> Union[int, ExitCode]:
+    """Perform an in-process test run.
+
+    :param args: List of command line arguments.
+    :param plugins: List of plugin objects to be auto-registered during initialization.
+
+    :returns: An exit code.
+    """
+    try:
+        try:
+            config = _prepareconfig(args, plugins)
+        except ConftestImportFailure as e:
+            exc_info = ExceptionInfo.from_exc_info(e.excinfo)
+            tw = TerminalWriter(sys.stderr)
+            tw.line(f"ImportError while loading conftest '{e.path}'.", red=True)
+            exc_info.traceback = exc_info.traceback.filter(
+                filter_traceback_for_conftest_import_failure
+            )
+            exc_repr = (
+                exc_info.getrepr(style="short", chain=False)
+                if exc_info.traceback
+                else exc_info.exconly()
+            )
+            formatted_tb = str(exc_repr)
+            for line in formatted_tb.splitlines():
+                tw.line(line.rstrip(), red=True)
+            return ExitCode.USAGE_ERROR
+        else:
+            try:
+                config.hook.pytest_collection_finish = pytest_collection_finish
+                ret: Union[ExitCode, int] = config.hook.pytest_cmdline_main(
+                    config=config
+                )
+                try:
+                    return ExitCode(ret)
+                except ValueError:
+                    return ret
+            finally:
+                config._ensure_unconfigure()
+    except UsageError as e:
+        tw = TerminalWriter(sys.stderr)
+        for msg in e.args:
+            tw.line(f"ERROR: {msg}\n", red=True)
+        return ExitCode.USAGE_ERROR
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit/runners/run.py

@@ -9,6 +9,8 @@ import subprocess
 from pathlib import Path
 from typing import List, Dict, Optional, Tuple
 
+from sflkit.logger import LOGGER
+
 Environment = Dict[str, str]
 
 PYTEST_RESULT_PATTERN = re.compile(
@@ -118,6 +120,15 @@ class VoidRunner(Runner):
 
 
 class PytestRunner(Runner):
+    def __init__(
+        self,
+        re_filter: str = r".*",
+        timeout=DEFAULT_TIMEOUT,
+        set_python_path: bool = False,
+    ):
+        super().__init__(re_filter, timeout)
+        self.set_python_path = set_python_path
+
     @staticmethod
     def _common_base(directory: Path, tests: List[str]) -> Path:
         parts = directory.parts
@@ -165,25 +176,49 @@ class PytestRunner(Runner):
         directory = directory.absolute()
         if files:
             if isinstance(files, (str, os.PathLike)):
-                c.append(files)
+                c.append(str(files))
             else:
-                c += files
+                c += [str(f) for f in files]
         if base:
             if not files:
-                c.append(base)
+                c.append(str(base))
             root_dir = directory / base
         else:
             root_dir = directory
-        output = subprocess.run(
-            ["python", "-m", "pytest", "--collect-only", "-q"] + c,
+        tmp = Path(f"tmp_sflkit_pytest_tmp_{id(self)}").absolute()
+        pytest_main = (
+            Path(__file__).parent.resolve() / "resources" / "pytest_main.py"
+        ).absolute()
+        environ = dict(environ or os.environ)
+        environ["SFLKIT_PYTEST_COLLECTION_FINISH_FILE"] = str(tmp)
+        if self.set_python_path:
+            if "PYTHONPATH" in environ:
+                environ["PYTHONPATH"] = str(directory) + ":" + environ["PYTHONPATH"]
+            else:
+                environ["PYTHONPATH"] = str(directory)
+        process = subprocess.run(
+            [
+                "python3",
+                str(pytest_main),
+                "--collect-only",
+            ]
+            + c,
             stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
             env=environ,
             cwd=directory,
-        ).stdout.decode("utf-8")
-        tests = output.split("\n\n", 1)[0].split("\n")
-        if tests[-1] == "":
-            tests = tests[:-1]
-        return self._normalize_paths(tests, directory, root_dir)
+        )
+        LOGGER.info(f"pytest collection finished with {process.returncode}")
+        if not tmp.exists():
+            tmp = directory / "tmp_sflkit_pytest"
+        if tmp.exists():
+            with open(tmp, "r") as f:
+                tests = [line.strip() for line in f.readlines()]
+            os.remove(tmp)
+            return self._normalize_paths(tests, directory, root_dir)
+        else:
+            LOGGER.warn(f"Could not find {tmp}")
+            return []
 
     @staticmethod
     def __get_pytest_result__(
@@ -207,7 +242,7 @@ class PytestRunner(Runner):
     ) -> TestResult:
         try:
             output = subprocess.run(
-                ["python", "-m", "pytest", test],
+                ["python3", "-m", "pytest", test],
                 stdout=subprocess.PIPE,
                 env=environ,
                 cwd=directory,
@@ -288,7 +323,7 @@ class InputRunner(Runner):
             result = TestResult.FAILING
         try:
             process = subprocess.run(
-                ["python", self.access] + test,
+                ["python3", self.access] + test,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 env=environ,

{sflkit-0.2.17 → sflkit-0.2.19/src/sflkit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sflkit
-Version: 0.2.17
+Version: 0.2.19
 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/

{sflkit-0.2.17 → sflkit-0.2.19}/src/sflkit.egg-info/SOURCES.txt

@@ -42,6 +42,8 @@ src/sflkit/model/model.py
 src/sflkit/model/scope.py
 src/sflkit/runners/__init__.py
 src/sflkit/runners/run.py
+src/sflkit/runners/resources/__init__.py
+src/sflkit/runners/resources/pytest_main.py
 tests/test_analysis_objects.py
 tests/test_cli.py
 tests/test_color.py

{sflkit-0.2.17 → sflkit-0.2.19}/tests/test_config.py

@@ -93,6 +93,7 @@ class ConfigTests(unittest.TestCase):
             config.visitor,
             config.passing,
             config.failing,
+            config.mapping,
             config.instrument_include,
             config.instrument_exclude,
             config.instrument_working,

{sflkit-0.2.17 → sflkit-0.2.19}/tests/test_instrumentation.py

@@ -2,8 +2,7 @@ import atexit
 import os
 from pathlib import Path
 
-from parameterized import parameterized
-from sflkitlib.events import event, EventType
+from sflkitlib.events import EventType
 
 from sflkit import instrument_config, Config
 from utils import BaseTest
@@ -106,6 +105,76 @@ class TestInstrumentation(BaseTest):
             )
         )
 
+    def test_mapping_output(self):
+        instrument_config(
+            Config.create(
+                path=os.path.join(BaseTest.TEST_RESOURCES, "test_instrumentation"),
+                language="python",
+                events="line",
+                predicates="line",
+                working=BaseTest.TEST_DIR,
+                mapping_path="mapping.json",
+            )
+        )
+        mapping = Path("mapping.json")
+        self.assertTrue(mapping.exists())
+        self.assertTrue(mapping.is_file())
+
+    def test_instrument_exclude(self):
+        src = Path(BaseTest.TEST_RESOURCES, "test_exclude")
+        dst = Path(BaseTest.TEST_DIR)
+        instrument_config(
+            Config.create(
+                path=str(src),
+                language="python",
+                events="line",
+                predicates="line",
+                working=BaseTest.TEST_DIR,
+                include="included",
+                exclude=os.path.join("included", "excluded"),
+            )
+        )
+        included = dst / "included"
+        excluded = included / "excluded"
+        a = included / "a.py"
+        b = excluded / "b.py"
+        c = dst / "c.py"
+
+        included_src = src / "included"
+        excluded_src = included_src / "excluded"
+        a_src = included_src / "a.py"
+        b_src = excluded_src / "b.py"
+        c_src = src / "c.py"
+
+        self.assertTrue(included.exists())
+        self.assertTrue(included.is_dir())
+        self.assertTrue(excluded.exists())
+        self.assertTrue(excluded.is_dir())
+        self.assertTrue(a.exists())
+        self.assertTrue(a.is_file())
+        self.assertTrue(b.exists())
+        self.assertTrue(b.is_file())
+        self.assertTrue(c.exists())
+        self.assertTrue(c.is_file())
+
+        with open(a, "r") as fp:
+            a_content = fp.read()
+        with open(a_src, "r") as fp:
+            a_src_content = fp.read()
+        self.assertNotEqual(a_src_content, a_content)
+
+        with open(b, "r") as fp:
+            b_content = fp.read()
+        with open(b_src, "r") as fp:
+            b_src_content = fp.read()
+        self.assertEqual(b_src_content, b_content)
+
+        with open(c, "r") as fp:
+            c_content = fp.read()
+        with open(c_src, "r") as fp:
+            c_src_content = fp.read()
+        self.assertEqual(c_src_content, c_content)
+
 
 class TestLib(BaseTest):
     @classmethod
@@ -131,10 +200,6 @@ class TestLib(BaseTest):
     def setUp(self) -> None:
         self.events = None
 
-    def load(self) -> None:
-        self.lib.dump_events()
-        self.events = event.load(self.TEST_PATH)
-
     def tearDown(self) -> None:
         # noinspection PyBroadException
         try:

{sflkit-0.2.17 → sflkit-0.2.19}/tests/test_runner.py

@@ -37,7 +37,7 @@ class RunnerTests(BaseTest):
             exclude="tests",
         )
         instrument_config(config)
-        runner = PytestRunner()
+        runner = PytestRunner(set_python_path=True)
         output = Path(BaseTest.TEST_DIR, "events").absolute()
         runner.run(
             Path(BaseTest.TEST_DIR), output, files=[Path("tests", "test_middle.py")]