smallworld-re 1.0.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

smallworld/analyses/__init__.py

@@ -1,14 +1,22 @@
 from .analysis import *  # noqa: F401, F403
 from .analysis import __all__ as __analysis__
 from .colorizer import Colorizer
+from .colorizer_def_use import ColorizerDefUse
 from .colorizer_summary import ColorizerSummary
 from .field_detection import FieldDetectionAnalysis, ForcedFieldDetectionAnalysis
 from .forced_exec import ForcedExecution
+from .trace_execution import TraceExecution
+from .trace_execution_types import CmpInfo, TraceElement, TraceRes
 
 __all__ = __analysis__ + [
     "Colorizer",
     "ColorizerSummary",
+    "ColorizerDefUse",
     "FieldDetectionAnalysis",
     "ForcedFieldDetectionAnalysis",
     "ForcedExecution",
+    "TraceExecution",
+    "TraceElement",
+    "TraceRes",
+    "CmpInfo",
 ]

smallworld/analyses/analysis.py

@@ -1,13 +1,17 @@
 import abc
-import logging
-import typing
 
-from .. import hinting, state, utils
+from smallworld.hinting.hinting import Hinter
+
+from .. import state, utils
 
 
 class Analysis(utils.MetadataMixin):
     """An analysis that emits some information about some code, possibly to help with harnessing."""
 
+    def __init__(self, hinter: Hinter, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+        self.hinter = hinter
+
     @abc.abstractmethod
     def run(self, machine: state.Machine) -> None:
         """Run the analysis.
@@ -22,67 +26,4 @@ class Analysis(utils.MetadataMixin):
         pass
 
 
-class Filter(utils.MetadataMixin):
-    """Analyses that consume and sometimes produce additional hints.
-
-    Filter analyses are analyses that consume some part of the hint
-    stream and possibly emit new higher-level, synthetic hints. These
-    analyses do not inspect machine state directly, they just react to
-    hints from other analyses.
-
-    """
-
-    def __init__(self):
-        self.listeners = []
-
-    def listen(
-        self,
-        hint: typing.Type[hinting.Hint],
-        method: typing.Callable[[hinting.Hint], None],
-    ) -> None:
-        """Register a listener for a particular hint type on the hint stream.
-
-        Arguments:
-            hint: A hint type that should trigger this listener. Note: All
-                subclasses `hint` will trigger the listener.
-            method: The method to call when the given hint type is observed.
-        """
-
-        class Handler(logging.Handler):
-            def emit(self, record):
-                method(record.msg)
-
-        handler = Handler()
-        handler.setLevel(logging.DEBUG)
-        handler.addFilter(hinting.HintSubclassFilter(hint))
-        hinting.root.addHandler(handler)
-
-        self.listeners.append(handler)
-
-    @abc.abstractmethod
-    def activate(self) -> None:
-        """Activate this filter.
-
-        Implementations should make necessary calls to `listen()` here to
-        register hint listener functions. They will be unregistered
-        automatically on destruction or manual call to `deactivate()`.
-        """
-
-        pass
-
-    def deactivate(self) -> None:
-        """Deactivate this filter.
-
-        This is done automatically on destruction of this object - you likely
-        shouldn't need to call this manually.
-        """
-
-        for handler in self.listeners:
-            hinting.root.removeHandler(handler)
-
-    def __del__(self):
-        self.deactivate()
-        # super().__del__()
-
-
-__all__ = ["Analysis", "Filter"]
+__all__ = ["Analysis"]

smallworld/analyses/code_coverage.py

@@ -5,7 +5,6 @@ from .. import emulators, hinting
 from . import analysis
 
 logger = logging.getLogger(__name__)
-hinter = hinting.get_hinter(__name__)
 
 
 class CodeCoverage(analysis.Analysis):
@@ -28,4 +27,4 @@ class CodeCoverage(analysis.Analysis):
                 coverage[pc] = 1
 
         hint = hinting.CoverageHint(message="Coverage for execution", coverage=coverage)
-        hinter.info(hint)
+        self.hinter.send(hint)