added tests, get reason for unsubmittable entities

taipy/core/_entity/submittable.py

@@ -88,7 +88,7 @@ class Submittable:
         Returns:
             True if the given entity is ready to be run. False otherwise.
         """
-        if self._submittable_id not in SubmittableStatusCache.submittable_id_datanodes:
+        if self._submittable_id not in SubmittableStatusCache._submittable_id_datanodes:
             for dn in self.get_inputs():
                 SubmittableStatusCache._compute_if_dn_is_ready_for_reading(dn)
         return SubmittableStatusCache._check_submittable_is_ready_to_submit(self._submittable_id)

taipy/core/notification/_submittable_status_cache.py

@@ -12,35 +12,48 @@
 from collections import defaultdict
 from typing import TYPE_CHECKING, Dict, Set
 
+from ..notification import EventOperation, Notifier, _make_event
+
 if TYPE_CHECKING:
     from ..data.data_node import DataNode, DataNodeId
 
 
 class SubmittableStatusCache:
+    IS_SUBMITTABLE_FCT_NAME = "is_submittable"
+
     # A dictionary representing not ready_to_read datanode and its equivalent submittable entities
-    datanode_id_submittables: Dict["DataNodeId", Set[str]] = defaultdict(lambda: set())
+    _datanode_id_submittables: Dict["DataNodeId", Set[str]] = defaultdict(lambda: set())
 
     # A nested dictionary representing the submittable entities (Scenario, Sequence, Task) and
     # its equivalent not ready_to_read input datanodes
-    submittable_id_datanodes: Dict[str, Dict["DataNodeId", str]] = defaultdict(defaultdict)
+    _submittable_id_datanodes: Dict[str, Dict["DataNodeId", str]] = defaultdict(defaultdict)
 
     @classmethod
     def __add(cls, entity_id: str, datanode_id: "DataNodeId", reason: str):
-        cls.datanode_id_submittables[datanode_id].add(entity_id)
-        cls.submittable_id_datanodes[entity_id][datanode_id] = reason
+        cls._datanode_id_submittables[datanode_id].add(entity_id)
+        cls._submittable_id_datanodes[entity_id][datanode_id] = reason
 
     @classmethod
     def __remove(cls, datanode_id: "DataNodeId"):
-        submittable_ids: Set = cls.datanode_id_submittables.pop(datanode_id, set())
+        from ..taipy import get as tp_get
+
+        submittable_ids: Set = cls._datanode_id_submittables.pop(datanode_id, set())
         for submittable_id in submittable_ids:
-            cls.submittable_id_datanodes[submittable_id].pop(datanode_id, None)
-            if len(cls.submittable_id_datanodes[submittable_id]) == 0:
-                # Notifier.publish(make_event(scenario, submittable, UPDATE))
-                cls.submittable_id_datanodes.pop(submittable_id, None)
+            cls._submittable_id_datanodes[submittable_id].pop(datanode_id, None)
+            if len(cls._submittable_id_datanodes[submittable_id]) == 0:
+                Notifier.publish(
+                    _make_event(
+                        tp_get(submittable_id),
+                        EventOperation.UPDATE,
+                        attribute_name=cls.IS_SUBMITTABLE_FCT_NAME,
+                        attribute_value=True,
+                    )
+                )
+                cls._submittable_id_datanodes.pop(submittable_id, None)
 
     @classmethod
     def _check_submittable_is_ready_to_submit(cls, entity_id: str):
-        return len(SubmittableStatusCache.submittable_id_datanodes.get(entity_id, [])) == 0
+        return len(SubmittableStatusCache._submittable_id_datanodes.get(entity_id, [])) == 0
 
     @classmethod
     def __add_parent_entities_to_submittable_cache(cls, dn: "DataNode", reason: str):
@@ -60,8 +73,14 @@ class SubmittableStatusCache:
     @classmethod
     def _compute_if_dn_is_ready_for_reading(cls, dn: "DataNode"):
         if dn._edit_in_progress:
-            cls.__add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is being edited.")
+            cls.__add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is being edited")
         elif not dn._last_edit_date:
-            cls.__add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is not written.")
+            cls.__add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is not written")
         elif dn.is_ready_for_reading:
             SubmittableStatusCache.__remove(dn.id)
+
+    @classmethod
+    def get_reason_submittable_is_not_ready_to_submit(cls, entity_id: str):
+        if reasons := list(cls._submittable_id_datanodes.get(entity_id, {}).values()):
+            return "; ".join(reasons) + "."
+        return ""

tests/core/notification/test_events_published.py

@@ -156,8 +156,8 @@ def test_events_published_for_writing_dn():
 
 
 def test_events_published_for_scenario_submission():
-    input_config = Config.configure_data_node("the_input")
-    output_config = Config.configure_data_node("the_output")
+    input_config = Config.configure_pickle_data_node("the_input")
+    output_config = Config.configure_pickle_data_node("the_output")
     task_config = Config.configure_task("the_task", identity, input=input_config, output=output_config)
     sc_config = Config.configure_scenario(
         "the_scenario", task_configs=[task_config], frequency=Frequency.DAILY, sequences={"the_seq": [task_config]}
@@ -167,6 +167,7 @@ def test_events_published_for_scenario_submission():
     register_id_0, register_queue_0 = Notifier.register()
     all_evts = RecordingConsumer(register_id_0, register_queue_0)
     all_evts.start()
+    # Write value to the unwritten data node trigger 3 is_submittable update events for the scenario, sequence and task
     # Submit a scenario triggers:
     # 1 scenario submission event
     # 7 dn update events (for last_edit_date, editor_id(x2), editor_expiration_date(x2) and edit_in_progress(x2))
@@ -178,16 +179,17 @@ def test_events_published_for_scenario_submission():
     # 1 submission update event for is_completed
     scenario.submit()
     snapshot = all_evts.capture()
-    assert len(snapshot.collected_events) == 17
+
+    assert len(snapshot.collected_events) == 20
     assert snapshot.entity_type_collected.get(EventEntityType.CYCLE, 0) == 0
     assert snapshot.entity_type_collected.get(EventEntityType.DATA_NODE, 0) == 7
-    assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 0
-    assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 1
+    assert snapshot.entity_type_collected.get(EventEntityType.TASK, 0) == 1
+    assert snapshot.entity_type_collected.get(EventEntityType.SEQUENCE, 0) == 1
+    assert snapshot.entity_type_collected.get(EventEntityType.SCENARIO, 0) == 2
     assert snapshot.entity_type_collected.get(EventEntityType.JOB, 0) == 4
     assert snapshot.entity_type_collected.get(EventEntityType.SUBMISSION, 0) == 5
     assert snapshot.operation_collected.get(EventOperation.CREATION, 0) == 2
-    assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 14
+    assert snapshot.operation_collected.get(EventOperation.UPDATE, 0) == 17
     assert snapshot.operation_collected.get(EventOperation.SUBMISSION, 0) == 1
 
     assert snapshot.attr_name_collected["last_edit_date"] == 1
@@ -197,6 +199,7 @@ def test_events_published_for_scenario_submission():
     assert snapshot.attr_name_collected["status"] == 3
     assert snapshot.attr_name_collected["jobs"] == 1
     assert snapshot.attr_name_collected["submission_status"] == 3
+    assert snapshot.attr_name_collected["is_submittable"] == 3
 
     all_evts.stop()
 

tests/core/notification/test_submittable_status_cache.py

@@ -0,0 +1,58 @@
+# Copyright 2021-2024 Avaiga Private Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+# the License. You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations under the License.
+
+from datetime import datetime
+
+from taipy.config import Config, Frequency
+from taipy.core.notification._submittable_status_cache import SubmittableStatusCache
+from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory
+
+
+def test_get_reason_submittable_is_not_ready_to_submit():
+    scenario_manager = _ScenarioManagerFactory._build_manager()
+    assert len(scenario_manager._get_all()) == 0
+
+    dn_config_1 = Config.configure_pickle_data_node("dn_1", default_data=10)
+    dn_config_2 = Config.configure_pickle_data_node("dn_2", default_data=15)
+    task_config = Config.configure_task("task", print, [dn_config_1, dn_config_2])
+    scenario_config = Config.configure_scenario("sc", {task_config}, set(), Frequency.DAILY)
+    scenario = scenario_manager._create(scenario_config)
+    dn_1 = scenario.dn_1
+    dn_2 = scenario.dn_2
+
+    dn_2.edit_in_progress = True
+    assert not scenario.is_ready_to_run()
+    assert not scenario_manager._is_submittable(scenario)
+    assert (
+        SubmittableStatusCache.get_reason_submittable_is_not_ready_to_submit(scenario.id)
+        == f"DataNode {dn_2.id} is being edited."
+    )
+
+    dn_1.last_edit_date = None
+    assert not scenario.is_ready_to_run()
+    assert not scenario_manager._is_submittable(scenario)
+    assert (
+        SubmittableStatusCache.get_reason_submittable_is_not_ready_to_submit(scenario.id)
+        == f"DataNode {dn_2.id} is being edited; DataNode {dn_1.id} is not written."
+    )
+
+    dn_2.edit_in_progress = False
+    assert not scenario.is_ready_to_run()
+    assert not scenario_manager._is_submittable(scenario)
+    assert (
+        SubmittableStatusCache.get_reason_submittable_is_not_ready_to_submit(scenario.id)
+        == f"DataNode {dn_1.id} is not written."
+    )
+
+    dn_1.last_edit_date = datetime.now()
+    assert scenario.is_ready_to_run()
+    assert scenario_manager._is_submittable(scenario)
+    assert SubmittableStatusCache.get_reason_submittable_is_not_ready_to_submit(scenario.id) == ""

tests/core/scenario/test_scenario_manager.py

@@ -590,7 +590,11 @@ def test_notification_subscribe(mocker):
 
     notify_1 = NotifyMock(scenario)
     notify_2 = NotifyMock(scenario)
-    mocker.patch.object(_utils, "_load_fct", side_effect=[notify_1, notify_1, notify_1, notify_2, notify_2, notify_2])
+    mocker.patch.object(
+        _utils,
+        "_load_fct",
+        side_effect=[notify_1, notify_1, notify_1, notify_1, notify_2, notify_2, notify_2, notify_2],
+    )
 
     # test subscribing notification
     _ScenarioManager._subscribe(callback=notify_1, scenario=scenario)
@@ -943,63 +947,63 @@ def test_is_submittable():
     dn_2 = scenario.dn_2
 
     assert len(_ScenarioManager._get_all()) == 1
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
     assert _ScenarioManager._is_submittable(scenario)
     assert _ScenarioManager._is_submittable(scenario.id)
     assert not _ScenarioManager._is_submittable("Scenario_temp")
 
     dn_1.edit_in_progress = True
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
     )
     assert not _ScenarioManager._is_submittable(scenario)
     assert not _ScenarioManager._is_submittable(scenario.id)
 
     dn_1.edit_in_progress = False
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id not in SubmittableStatusCache.datanode_id_submittables
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id not in SubmittableStatusCache._datanode_id_submittables
     assert _ScenarioManager._is_submittable(scenario)
     assert _ScenarioManager._is_submittable(scenario.id)
 
     dn_1.last_edit_date = None
     dn_2.edit_in_progress = True
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
-    assert dn_2.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
+    assert dn_2.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
     )
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
     assert not _ScenarioManager._is_submittable(scenario)
     assert not _ScenarioManager._is_submittable(scenario.id)
 
     dn_1.last_edit_date = datetime.now()
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id not in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id not in SubmittableStatusCache.datanode_id_submittables
-    assert dn_2.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id not in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id not in SubmittableStatusCache._datanode_id_submittables
+    assert dn_2.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
     assert not _ScenarioManager._is_submittable(scenario)
     assert not _ScenarioManager._is_submittable(scenario.id)
 
     dn_2.edit_in_progress = False
-    assert dn_1.id not in SubmittableStatusCache.datanode_id_submittables
-    assert dn_2.id not in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
+    assert dn_1.id not in SubmittableStatusCache._datanode_id_submittables
+    assert dn_2.id not in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
     assert _ScenarioManager._is_submittable(scenario)
     assert _ScenarioManager._is_submittable(scenario.id)
 

tests/core/sequence/test_sequence_manager.py

@@ -209,8 +209,8 @@ def test_is_submittable():
     scenario.add_sequences({"sequence": [task]})
     sequence = scenario.sequences["sequence"]
     assert len(_SequenceManager._get_all()) == 1
-    assert sequence.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
+    assert sequence.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
     assert _SequenceManager._is_submittable(sequence)
     assert _SequenceManager._is_submittable(sequence.id)
     assert _ScenarioManager._is_submittable(scenario)
@@ -218,88 +218,88 @@ def test_is_submittable():
     assert not _SequenceManager._is_submittable("SEQUENCE_temp_SCENARIO_scenario")
 
     dn_1.edit_in_progress = True
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert sequence.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[sequence.id]
-    assert dn_1.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
-    assert sequence.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert sequence.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[sequence.id]
+    assert dn_1.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
+    assert sequence.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
     )
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[sequence.id][dn_1.id] == f"DataNode {dn_1.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[sequence.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
     )
     assert not _ScenarioManager._is_submittable(scenario)
     assert not _SequenceManager._is_submittable(sequence)
     assert not _SequenceManager._is_submittable(sequence.id)
 
     dn_1.edit_in_progress = False
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert sequence.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id not in SubmittableStatusCache.datanode_id_submittables
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert sequence.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id not in SubmittableStatusCache._datanode_id_submittables
     assert _SequenceManager._is_submittable(sequence)
     assert _SequenceManager._is_submittable(sequence.id)
     assert _ScenarioManager._is_submittable(scenario)
 
     dn_1.last_edit_date = None
     dn_2.edit_in_progress = True
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert sequence.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[sequence.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[sequence.id]
-    assert dn_1.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
-    assert sequence.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
-    assert dn_2.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
-    assert sequence.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert sequence.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[sequence.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[sequence.id]
+    assert dn_1.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
+    assert sequence.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
+    assert dn_2.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
+    assert sequence.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
     )
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[sequence.id][dn_1.id] == f"DataNode {dn_1.id} is not written."
+        SubmittableStatusCache._submittable_id_datanodes[sequence.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
     )
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[sequence.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[sequence.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
     assert not _ScenarioManager._is_submittable(scenario)
     assert not _SequenceManager._is_submittable(sequence)
     assert not _SequenceManager._is_submittable(sequence.id)
 
     dn_1.last_edit_date = datetime.now()
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert sequence.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id not in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id not in SubmittableStatusCache.submittable_id_datanodes[sequence.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[sequence.id]
-    assert dn_1.id not in SubmittableStatusCache.datanode_id_submittables
-    assert dn_2.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
-    assert sequence.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert sequence.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id not in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id not in SubmittableStatusCache._submittable_id_datanodes[sequence.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[sequence.id]
+    assert dn_1.id not in SubmittableStatusCache._datanode_id_submittables
+    assert dn_2.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
+    assert sequence.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[sequence.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[sequence.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
     assert not _ScenarioManager._is_submittable(scenario)
     assert not _SequenceManager._is_submittable(sequence)
     assert not _SequenceManager._is_submittable(sequence.id)
 
     dn_2.edit_in_progress = False
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert sequence.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_2.id not in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id not in SubmittableStatusCache.submittable_id_datanodes[sequence.id]
-    assert dn_2.id not in SubmittableStatusCache.datanode_id_submittables
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert sequence.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_2.id not in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id not in SubmittableStatusCache._submittable_id_datanodes[sequence.id]
+    assert dn_2.id not in SubmittableStatusCache._datanode_id_submittables
     assert _ScenarioManager._is_submittable(scenario)
     assert _SequenceManager._is_submittable(sequence)
     assert _SequenceManager._is_submittable(sequence.id)
@@ -564,7 +564,11 @@ def test_sequence_notification_subscribe(mocker):
     notify_2.__module__ = "notify_2"
     # Mocking this because NotifyMock is a class that does not loads correctly when getting the sequence
     # from the storage.
-    mocker.patch.object(_utils, "_load_fct", side_effect=[notify_1, notify_1, notify_2, notify_2, notify_2, notify_2])
+    mocker.patch.object(
+        _utils,
+        "_load_fct",
+        side_effect=[notify_1, notify_1, notify_1, notify_2, notify_2, notify_2, notify_2, notify_2],
+    )
 
     # test subscription
     callback = mock.MagicMock()

tests/core/task/test_task_manager.py

@@ -323,8 +323,8 @@ def test_is_submittable():
     assert len(task_manager._get_all()) == 1
     assert len(scenario_manager._get_all()) == 1
 
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert task.id not in SubmittableStatusCache.submittable_id_datanodes
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert task.id not in SubmittableStatusCache._submittable_id_datanodes
     assert task_manager._is_submittable(task)
     assert task_manager._is_submittable(task.id)
     assert scenario_manager._is_submittable(scenario)
@@ -332,80 +332,80 @@ def test_is_submittable():
     assert not task_manager._is_submittable("Task_temp")
 
     dn_1.edit_in_progress = True
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert task.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[task.id]
-    assert dn_1.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
-    assert task.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert task.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[task.id]
+    assert dn_1.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
+    assert task.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
     )
-    assert SubmittableStatusCache.submittable_id_datanodes[task.id][dn_1.id] == f"DataNode {dn_1.id} is being edited."
+    assert SubmittableStatusCache._submittable_id_datanodes[task.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
     assert not scenario_manager._is_submittable(scenario)
     assert not task_manager._is_submittable(task)
     assert not task_manager._is_submittable(task.id)
 
     dn_1.edit_in_progress = False
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert task.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id not in SubmittableStatusCache.datanode_id_submittables
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert task.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id not in SubmittableStatusCache._datanode_id_submittables
     assert scenario_manager._is_submittable(scenario)
     assert task_manager._is_submittable(task)
     assert task_manager._is_submittable(task.id)
 
     dn_1.last_edit_date = None
     dn_2.edit_in_progress = True
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert task.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id in SubmittableStatusCache.submittable_id_datanodes[task.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[task.id]
-    assert dn_1.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
-    assert task.id in SubmittableStatusCache.datanode_id_submittables[dn_1.id]
-    assert dn_2.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
-    assert task.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert task.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in SubmittableStatusCache._submittable_id_datanodes[task.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[task.id]
+    assert dn_1.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
+    assert task.id in SubmittableStatusCache._datanode_id_submittables[dn_1.id]
+    assert dn_2.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
+    assert task.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
     )
-    assert SubmittableStatusCache.submittable_id_datanodes[task.id][dn_1.id] == f"DataNode {dn_1.id} is not written."
+    assert SubmittableStatusCache._submittable_id_datanodes[task.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
-    assert SubmittableStatusCache.submittable_id_datanodes[task.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+    assert SubmittableStatusCache._submittable_id_datanodes[task.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     assert not scenario_manager._is_submittable(scenario)
     assert not task_manager._is_submittable(task)
     assert not task_manager._is_submittable(task.id)
 
     dn_1.last_edit_date = datetime.now()
-    assert scenario.id in SubmittableStatusCache.submittable_id_datanodes
-    assert task.id in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_1.id not in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_1.id not in SubmittableStatusCache.submittable_id_datanodes[task.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id in SubmittableStatusCache.submittable_id_datanodes[task.id]
-    assert dn_1.id not in SubmittableStatusCache.datanode_id_submittables
-    assert dn_2.id in SubmittableStatusCache.datanode_id_submittables
-    assert scenario.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
-    assert task.id in SubmittableStatusCache.datanode_id_submittables[dn_2.id]
+    assert scenario.id in SubmittableStatusCache._submittable_id_datanodes
+    assert task.id in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_1.id not in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_1.id not in SubmittableStatusCache._submittable_id_datanodes[task.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in SubmittableStatusCache._submittable_id_datanodes[task.id]
+    assert dn_1.id not in SubmittableStatusCache._datanode_id_submittables
+    assert dn_2.id in SubmittableStatusCache._datanode_id_submittables
+    assert scenario.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
+    assert task.id in SubmittableStatusCache._datanode_id_submittables[dn_2.id]
     assert (
-        SubmittableStatusCache.submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+        SubmittableStatusCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     )
-    assert SubmittableStatusCache.submittable_id_datanodes[task.id][dn_2.id] == f"DataNode {dn_2.id} is being edited."
+    assert SubmittableStatusCache._submittable_id_datanodes[task.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
     assert not scenario_manager._is_submittable(scenario)
     assert not task_manager._is_submittable(task)
     assert not task_manager._is_submittable(task.id)
 
     dn_2.edit_in_progress = False
-    assert scenario.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert task.id not in SubmittableStatusCache.submittable_id_datanodes
-    assert dn_2.id not in SubmittableStatusCache.submittable_id_datanodes[scenario.id]
-    assert dn_2.id not in SubmittableStatusCache.submittable_id_datanodes[task.id]
-    assert dn_2.id not in SubmittableStatusCache.datanode_id_submittables
+    assert scenario.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert task.id not in SubmittableStatusCache._submittable_id_datanodes
+    assert dn_2.id not in SubmittableStatusCache._submittable_id_datanodes[scenario.id]
+    assert dn_2.id not in SubmittableStatusCache._submittable_id_datanodes[task.id]
+    assert dn_2.id not in SubmittableStatusCache._datanode_id_submittables
     assert scenario_manager._is_submittable(scenario)
     assert task_manager._is_submittable(task)
     assert task_manager._is_submittable(task.id)