fix: address SonarCloud code smells

- S1186: add comments to empty method bodies in tests
- S125: remove commented-out code in conftest.py and test_microwave.py
- S1192: extract _ERROR_EXECUTION constant in engines/base.py
- S108: invert condition to eliminate empty pass block in base engine
- S5713: remove redundant IndentationError (subclass of SyntaxError)
- S1940: use != instead of not == in processor.py
- S2772: remove unneeded pass in schema.py Action dataclass
- S1854: remove dead assignment to all_initial_states in parser.py
- S5806: rename id -> func_id to avoid shadowing builtin in spec_parser.py
- S1172: remove unused is_root parameter from diagram._graph_states
- S5655: fix Events.match type hint to accept str | None
- S5886: fix return type of create_machine_class_from_definition

Author: fgmacedo

conftest.py

@@ -44,31 +44,3 @@ def has_dot_installed():
 def requires_dot_installed(request, has_dot_installed):
     if not has_dot_installed:
         pytest.skip(f"Test {request.node.nodeid} requires 'dot' that is not installed.")
-
-
-# @pytest.fixture(autouse=True, scope="module")
-# def mock_dot_write(request):
-#     """
-#     This fixture avoids updating files while executing tests
-#     """
-
-#     def open_effect(
-#         filename,
-#         mode="r",
-#         *args,
-#         **kwargs,
-#     ):
-#         if mode in ("r", "rt", "rb"):
-#             return open(filename, mode, *args, **kwargs)
-#         elif filename.startswith("/tmp/"):
-#             return open(filename, mode, *args, **kwargs)
-#         elif "b" in mode:
-#             return io.BytesIO()
-#         else:
-#             return io.StringIO()
-
-#     # using global mock instead of the fixture mocker due to the ScopeMismatch
-#     # this fixture is module scoped and mocker is function scoped
-#     with mock.patch("pydot.core.io.open", spec=True) as m:
-#         m.side_effect = open_effect
-#         yield m

statemachine/contrib/diagram.py

@@ -202,7 +202,7 @@ def _transition_as_edges(self, transition):
 
     def get_graph(self):
         graph = self._get_graph(self.machine)
-        self._graph_states(self.machine, graph, is_root=True)
+        self._graph_states(self.machine, graph)
         return graph
 
     def _add_transitions(self, graph, state):
@@ -212,7 +212,7 @@ def _add_transitions(self, graph, state):
             for edge in self._transition_as_edges(transition):
                 graph.add_edge(edge)
 
-    def _graph_states(self, state, graph, is_root=False):
+    def _graph_states(self, state, graph):
         initial_node = self._initial_node(state)
         initial_subgraph = pydot.Subgraph(
             graph_name=f"{initial_node.get_name()}_initial",

statemachine/engines/base.py

@@ -70,6 +70,9 @@ def remove(self, send_id: str):
             ]
 
 
+_ERROR_EXECUTION = "error.execution"
+
+
 class BaseEngine:
     def __init__(self, sm: "StateChart"):
         self._sm: ReferenceType["StateChart"] = ref(sm)
@@ -138,7 +141,7 @@ def handler(error: Exception) -> None:
             # new error.execution is a separate event that may trigger a different
             # transition (see W3C test 152).  The infinite-loop guard lives at the
             # *microstep* level (in ``_send_error_execution``), not here.
-            self.sm.send("error.execution", error=error, internal=True)
+            self.sm.send(_ERROR_EXECUTION, error=error, internal=True)
 
         return handler
 
@@ -159,10 +162,10 @@ def _send_error_execution(self, error: Exception, trigger_data: TriggerData):
         If already processing an error.execution event, ignore to avoid infinite loops.
         """
         logger.debug("Error %s captured while executing event=%s", error, trigger_data.event)
-        if trigger_data.event and str(trigger_data.event) == "error.execution":
+        if trigger_data.event and str(trigger_data.event) == _ERROR_EXECUTION:
             logger.warning("Error while processing error.execution, ignoring: %s", error)
             return
-        self.sm.send("error.execution", error=error, internal=True)
+        self.sm.send(_ERROR_EXECUTION, error=error, internal=True)
 
     def start(self):
         if self.sm.current_state_value is not None:
@@ -755,18 +758,16 @@ def add_descendant_states_to_enter(  # noqa: C901
 
         # Add the state to the entry set
         if (
-            not self.sm.enable_self_transition_entries
-            and info.transition.internal
-            and (
+            self.sm.enable_self_transition_entries
+            or not info.transition.internal
+            or not (
                 info.transition.is_self
                 or (
                     info.transition.target
                     and info.transition.target.is_descendant(info.transition.source)
                 )
             )
         ):
-            pass
-        else:
             states_to_enter.add(info)
         state = info.state
 

statemachine/events.py

@@ -34,7 +34,7 @@ def add(self, events):
 
         return self
 
-    def match(self, event: str):
+    def match(self, event: "str | None"):
         if event is None and self.is_empty:
             return True
         return any(e.match(event) for e in self)

statemachine/io/__init__.py

@@ -145,7 +145,7 @@ def _parse_states(
 
 def create_machine_class_from_definition(
     name: str, states: Mapping[str, "StateKwargs | StateDefinition"], **definition
-) -> StateChart:  # noqa: C901
+) -> "type[StateChart]":  # noqa: C901
     """Create a StateChart class dynamically from a dictionary definition.
 
     Args:

statemachine/io/scxml/actions.py

@@ -368,7 +368,7 @@ def create_send_action_callable(action: SendAction) -> Callable:  # noqa: C901
     if action.content:
         try:
             content = (eval(action.content, {}, {}),)
-        except (NameError, IndentationError, SyntaxError, TypeError):
+        except (NameError, SyntaxError, TypeError):
             content = (action.content,)
 
     def send_action(*args, **kwargs):

statemachine/io/scxml/parser.py

@@ -31,7 +31,7 @@ def strip_namespaces(tree: ET.Element):
         if "}" in el.tag:
             el.tag = el.tag.split("}", 1)[1]
         attrib = el.attrib
-        for name in list(attrib.keys()):
+        for name in list(attrib.keys()):  # list() needed: loop mutates attrib
             if "}" in name:
                 new_name = name.split("}", 1)[1]
                 attrib[new_name] = attrib.pop(name)
@@ -78,7 +78,6 @@ def parse_scxml(scxml_content: str) -> StateMachineDefinition:  # noqa: C901
     # If no initial state was specified, pick the first state
     if not all_initial_states and definition.states:
         first_state = next(iter(definition.states.keys()))
-        all_initial_states = {first_state}
         definition.initial_states = [first_state]
         definition.states[first_state].initial = True
 

statemachine/io/scxml/processor.py

@@ -111,7 +111,7 @@ def _prepare_event(self, *args, event: Event, **kwargs):
         machine = kwargs["machine"]
         session_data = self._get_session(machine)
 
-        if not session_data.first_event_raised and event and not event == "__initial__":
+        if not session_data.first_event_raised and event and event != "__initial__":
             session_data.first_event_raised = True
 
         _event: "EventDataWrapper | None" = None

statemachine/io/scxml/schema.py

@@ -7,8 +7,6 @@
 
 @dataclass
 class Action:
-    pass
-
     def __str__(self):
         return f"{self.__class__.__name__}"
 

statemachine/spec_parser.py

@@ -126,11 +126,11 @@ def register(func):
         return register
 
     @classmethod
-    def get(cls, id):
-        id = id.lower()
-        if id not in cls.registry:
-            raise ValueError(f"Unsupported function: {id}")
-        return cls.registry[id]
+    def get(cls, func_id):
+        func_id = func_id.lower()
+        if func_id not in cls.registry:
+            raise ValueError(f"Unsupported function: {func_id}")
+        return cls.registry[func_id]
 
 
 class InState: