refactored code and fixed tests

taipy/core/notification/_ready_to_run_cache.py → taipy/core/_entity/_ready_to_run_property.py

@@ -12,7 +12,7 @@
 from collections import defaultdict
 from typing import TYPE_CHECKING, Dict, Set, Union
 
-from . import EventOperation, Notifier, _make_event
+from ..notification import EventOperation, Notifier, _make_event
 
 if TYPE_CHECKING:
     from ..data.data_node import DataNode, DataNodeId
@@ -21,17 +21,17 @@ if TYPE_CHECKING:
     from ..task.task import TaskId
 
 
-class _ReadyToRunCache:
-    IS_SUBMITTABLE_PROPERTY_NAME = "is_submittable"
+class _ReadyToRunProperty:
+    IS_SUBMITTABLE_PROPERTY_NAME: str = "is_submittable"
 
     # A dictionary of the data nodes not ready_to_read and their corresponding submittable entities.
     _datanode_id_submittables: Dict["DataNodeId", Set[Union["ScenarioId", "SequenceId", "TaskId"]]] = defaultdict(set)
 
     # A nested dictionary of the submittable entities (Scenario, Sequence, Task) and
     # the data nodes that make it not ready_to_run with the reason(s)
-    _submittable_id_datanodes: Dict[Union["ScenarioId", "SequenceId", "TaskId"], Dict["DataNodeId", str]] = defaultdict(
-        defaultdict
-    )
+    _submittable_id_datanodes: Dict[
+        Union["ScenarioId", "SequenceId", "TaskId"], Dict["DataNodeId", Set[str]]
+    ] = defaultdict(lambda: defaultdict(set))
 
     @staticmethod
     def _publish_submittable_property_event(
@@ -43,30 +43,43 @@ class _ReadyToRunCache:
             _make_event(
                 tp_get(submittable_id),
                 EventOperation.UPDATE,
-                attribute_name=_ReadyToRunCache.IS_SUBMITTABLE_PROPERTY_NAME,
+                attribute_name=_ReadyToRunProperty.IS_SUBMITTABLE_PROPERTY_NAME,
                 attribute_value=submittable_property,
             )
         )
 
     @classmethod
-    def _add(cls, submittable_id: Union["ScenarioId", "SequenceId", "TaskId"], datanode_id: "DataNodeId", reason: str):
+    def __add_unsubmittable_reason(
+        cls, submittable_id: Union["ScenarioId", "SequenceId", "TaskId"], datanode_id: "DataNodeId", reason: str
+    ):
         cls._datanode_id_submittables[datanode_id].add(submittable_id)
         if submittable_id not in cls._submittable_id_datanodes:
             cls._publish_submittable_property_event(submittable_id, False)
-        cls._submittable_id_datanodes[submittable_id][datanode_id] = reason
+        cls._submittable_id_datanodes[submittable_id][datanode_id].add(reason)
 
     @classmethod
-    def _remove(cls, datanode_id: "DataNodeId"):
-        submittable_ids: Set = cls._datanode_id_submittables.pop(datanode_id, set())
+    def _remove(cls, datanode_id: "DataNodeId", reason: str):
+        # check the data node status to determine the reason to be removed
+        submittable_ids: Set = cls._datanode_id_submittables.get(datanode_id, set())
+
+        to_remove_dn = False
         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:
-                cls._publish_submittable_property_event(submittable_id, True)
-                cls._submittable_id_datanodes.pop(submittable_id, None)
+            # check remove the reason
+            if reason in cls._submittable_id_datanodes[submittable_id].get(datanode_id, set()):
+                cls._submittable_id_datanodes[submittable_id].get(datanode_id, set()).remove(reason)
+            if len(cls._submittable_id_datanodes[submittable_id][datanode_id]) == 0:
+                to_remove_dn = True
+                cls._submittable_id_datanodes[submittable_id].pop(datanode_id, None)
+                if len(cls._submittable_id_datanodes[submittable_id]) == 0:
+                    cls._publish_submittable_property_event(submittable_id, True)
+                    cls._submittable_id_datanodes.pop(submittable_id, None)
+
+        if to_remove_dn:
+            cls._datanode_id_submittables.pop(datanode_id)
 
     @classmethod
     def _check_submittable_is_ready_to_submit(cls, submittable_id: Union["ScenarioId", "SequenceId", "TaskId"]):
-        return len(_ReadyToRunCache._submittable_id_datanodes.get(submittable_id, [])) == 0
+        return len(_ReadyToRunProperty._submittable_id_datanodes.get(submittable_id, [])) == 0
 
     @classmethod
     def _add_parent_entities_to_submittable_cache(cls, dn: "DataNode", reason: str):
@@ -77,14 +90,8 @@ class _ReadyToRunCache:
         parent_entities = dn.get_parents()
 
         for scenario_parent in parent_entities.get(Scenario._MANAGER_NAME, []):
-            _ReadyToRunCache._add(scenario_parent.id, dn.id, reason)
+            _ReadyToRunProperty.__add_unsubmittable_reason(scenario_parent.id, dn.id, reason)
         for sequence_parent in parent_entities.get(Sequence._MANAGER_NAME, []):
-            _ReadyToRunCache._add(sequence_parent.id, dn.id, reason)
+            _ReadyToRunProperty.__add_unsubmittable_reason(sequence_parent.id, dn.id, reason)
         for task_parent in parent_entities.get(Task._MANAGER_NAME, []):
-            _ReadyToRunCache._add(task_parent.id, dn.id, reason)
-
-    @classmethod
-    def get_reason_submittable_is_not_ready_to_submit(cls, submittable_id: Union["ScenarioId", "SequenceId", "TaskId"]):
-        if reasons := list(cls._submittable_id_datanodes.get(submittable_id, {}).values()):
-            return "; ".join(reasons) + "."
-        return ""
+            _ReadyToRunProperty.__add_unsubmittable_reason(task_parent.id, dn.id, reason)

taipy/core/_entity/submittable.py

@@ -17,9 +17,8 @@ import networkx as nx
 
 from ..common._listattributes import _ListAttributes
 from ..common._utils import _Subscriber
-from ..data.data_node import DataNode, _compute_if_dn_is_ready_for_reading
+from ..data.data_node import DataNode
 from ..job.job import Job
-from ..notification._ready_to_run_cache import _ReadyToRunCache
 from ..submission.submission import Submission
 from ..task.task import Task
 from ._dag import _DAG
@@ -34,7 +33,7 @@ class Submittable:
         subscribers (List[Callable]): The list of callbacks to be called on `Job^`'s status change.
     """
 
-    def __init__(self, submittable_id: str, subscribers: Optional[List[_Subscriber]] = None):
+    def __init__(self, submittable_id: str, subscribers: Optional[List[_Subscriber]] = None) -> None:
         self._submittable_id = submittable_id
         self._subscribers = _ListAttributes(self, subscribers or [])
 
@@ -88,10 +87,7 @@ class Submittable:
         Returns:
             True if the given entity is ready to be run. False otherwise.
         """
-        if self._submittable_id not in _ReadyToRunCache._submittable_id_datanodes:
-            for dn in self.get_inputs():
-                _compute_if_dn_is_ready_for_reading(dn)
-        return _ReadyToRunCache._check_submittable_is_ready_to_submit(self._submittable_id)
+        return all(dn.is_ready_for_reading for dn in self.get_inputs())
 
     def data_nodes_being_edited(self) -> Set[DataNode]:
         """Return the set of data nodes of the submittable entity that are being edited.

taipy/core/data/data_node.py

@@ -25,38 +25,18 @@ from taipy.logger._taipy_logger import _TaipyLogger
 from .._entity._entity import _Entity
 from .._entity._labeled import _Labeled
 from .._entity._properties import _Properties
+from .._entity._ready_to_run_property import _ReadyToRunProperty
 from .._entity._reload import _Reloader, _self_reload, _self_setter
 from .._version._version_manager_factory import _VersionManagerFactory
 from ..common._warnings import _warn_deprecated
 from ..exceptions.exceptions import DataNodeIsBeingEdited, NoData
 from ..job.job_id import JobId
-from ..notification._ready_to_run_cache import _ReadyToRunCache
 from ..notification.event import Event, EventEntityType, EventOperation, _make_event
 from ._filter import _FilterDataNode
 from .data_node_id import DataNodeId, Edit
 from .operator import JoinOperator
 
 
-def _compute_if_dn_is_ready_for_reading(dn: "DataNode"):
-    if dn._edit_in_progress:
-        _ReadyToRunCache._add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is being edited")
-    elif not dn._last_edit_date:
-        _ReadyToRunCache._add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is not written")
-    elif dn.is_ready_for_reading:
-        _ReadyToRunCache._remove(dn.id)
-
-
-def _update_ready_for_reading(fct):
-    # This decorator must be wrapped before self_setter decorator as self_setter will run the function twice.
-
-    @functools.wraps(fct)
-    def _recompute_is_ready_for_reading(dn: "DataNode", *args, **kwargs):
-        fct(dn, *args, **kwargs)
-        _compute_if_dn_is_ready_for_reading(dn)
-
-    return _recompute_is_ready_for_reading
-
-
 class DataNode(_Entity, _Labeled):
     """Reference to a dataset.
 
@@ -184,6 +164,22 @@ class DataNode(_Entity, _Labeled):
         """
         return self._edits[-1] if self._edits else None
 
+    def __update_ready_for_reading(fct):
+        # This decorator must be wrapped before self_setter decorator as self_setter will run the function twice.
+        @functools.wraps(fct)
+        def _recompute_is_ready_for_reading(dn: "DataNode", *args, **kwargs):
+            fct(dn, *args, **kwargs)
+            if dn._edit_in_progress:
+                _ReadyToRunProperty._add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is being edited")
+            else:
+                _ReadyToRunProperty._remove(dn.id, f"DataNode {dn.id} is being edited")
+            if not dn._last_edit_date:
+                _ReadyToRunProperty._add_parent_entities_to_submittable_cache(dn, f"DataNode {dn.id} is not written")
+            else:
+                _ReadyToRunProperty._remove(dn.id, f"DataNode {dn.id} is not written")
+
+        return _recompute_is_ready_for_reading
+
     @property  # type: ignore
     @_self_reload(_MANAGER_NAME)
     def last_edit_date(self):
@@ -194,7 +190,7 @@ class DataNode(_Entity, _Labeled):
             return self._last_edit_date
 
     @last_edit_date.setter  # type: ignore
-    @_update_ready_for_reading
+    @__update_ready_for_reading
     @_self_setter(_MANAGER_NAME)
     def last_edit_date(self, val):
         self._last_edit_date = val
@@ -259,7 +255,7 @@ class DataNode(_Entity, _Labeled):
         return self._edit_in_progress
 
     @edit_in_progress.setter  # type: ignore
-    @_update_ready_for_reading
+    @__update_ready_for_reading
     @_self_setter(_MANAGER_NAME)
     def edit_in_progress(self, val):
         self._edit_in_progress = val

tests/core/notification/test_submittable_status_cache.py

@@ -1,58 +0,0 @@
-# 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._ready_to_run_cache import _ReadyToRunCache
-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 (
-        _ReadyToRunCache.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 (
-        _ReadyToRunCache.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 (
-        _ReadyToRunCache.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 _ReadyToRunCache.get_reason_submittable_is_not_ready_to_submit(scenario.id) == ""

tests/core/scenario/test_scenario_manager.py

@@ -19,6 +19,7 @@ from taipy.config.common.frequency import Frequency
 from taipy.config.common.scope import Scope
 from taipy.config.config import Config
 from taipy.core import Job
+from taipy.core._entity._ready_to_run_property import _ReadyToRunProperty
 from taipy.core._orchestrator._orchestrator import _Orchestrator
 from taipy.core._version._version_manager import _VersionManager
 from taipy.core.common import _utils
@@ -38,7 +39,6 @@ from taipy.core.exceptions.exceptions import (
     UnauthorizedTagError,
 )
 from taipy.core.job._job_manager import _JobManager
-from taipy.core.notification._ready_to_run_cache import _ReadyToRunCache
 from taipy.core.scenario._scenario_manager import _ScenarioManager
 from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory
 from taipy.core.scenario.scenario import Scenario
@@ -958,55 +958,61 @@ def test_is_submittable():
     dn_2 = scenario.dn_2
 
     assert len(_ScenarioManager._get_all()) == 1
-    assert scenario.id not in _ReadyToRunCache._submittable_id_datanodes
+    assert scenario.id not in _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id not in _ReadyToRunCache._datanode_id_submittables
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id not in _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert dn_2.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert dn_2.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_1.id] == {f"DataNode {dn_1.id} is not written"}
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id not in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id not in _ReadyToRunCache._datanode_id_submittables
-    assert dn_2.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id not in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id not in _ReadyToRunProperty._datanode_id_submittables
+    assert dn_2.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._datanode_id_submittables
-    assert dn_2.id not in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id not in _ReadyToRunCache._submittable_id_datanodes
+    assert dn_1.id not in _ReadyToRunProperty._datanode_id_submittables
+    assert dn_2.id not in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
     assert _ScenarioManager._is_submittable(scenario)
     assert _ScenarioManager._is_submittable(scenario.id)
 

tests/core/sequence/test_sequence_manager.py

@@ -20,6 +20,7 @@ import pytest
 
 from taipy.config.common.scope import Scope
 from taipy.config.config import Config
+from taipy.core._entity._ready_to_run_property import _ReadyToRunProperty
 from taipy.core._orchestrator._orchestrator import _Orchestrator
 from taipy.core._version._version_manager import _VersionManager
 from taipy.core.common import _utils
@@ -35,7 +36,6 @@ from taipy.core.exceptions.exceptions import (
     SequenceBelongsToNonExistingScenario,
 )
 from taipy.core.job._job_manager import _JobManager
-from taipy.core.notification._ready_to_run_cache import _ReadyToRunCache
 from taipy.core.scenario._scenario_manager import _ScenarioManager
 from taipy.core.scenario.scenario import Scenario
 from taipy.core.sequence._sequence_manager import _SequenceManager
@@ -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 _ReadyToRunCache._submittable_id_datanodes
-    assert scenario.id not in _ReadyToRunCache._submittable_id_datanodes
+    assert sequence.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
     assert _SequenceManager._is_submittable(sequence)
     assert _SequenceManager._is_submittable(sequence.id)
     assert _ScenarioManager._is_submittable(scenario)
@@ -218,72 +218,84 @@ def test_is_submittable():
     assert not _SequenceManager._is_submittable("SEQUENCE_temp_SCENARIO_scenario")
 
     dn_1.edit_in_progress = True
-    assert scenario.id in _ReadyToRunCache._submittable_id_datanodes
-    assert sequence.id in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[sequence.id]
-    assert dn_1.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert sequence.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
-    assert _ReadyToRunCache._submittable_id_datanodes[sequence.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert sequence.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[sequence.id]
+    assert dn_1.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert sequence.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_1.id] == {
+        f"DataNode {dn_1.id} is being edited"
+    }
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert sequence.id not in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id not in _ReadyToRunCache._datanode_id_submittables
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert sequence.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id not in _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert sequence.id in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[sequence.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[sequence.id]
-    assert dn_1.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert sequence.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert dn_2.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert sequence.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
-    assert _ReadyToRunCache._submittable_id_datanodes[sequence.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
-    assert _ReadyToRunCache._submittable_id_datanodes[sequence.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert sequence.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[sequence.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[sequence.id]
+    assert dn_1.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert sequence.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert dn_2.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert sequence.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_1.id] == {f"DataNode {dn_1.id} is not written"}
+    assert _ReadyToRunProperty._submittable_id_datanodes[sequence.id][dn_1.id] == {f"DataNode {dn_1.id} is not written"}
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_2.id] == {
+        f"DataNode {dn_2.id} is being edited"
+    }
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert sequence.id in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id not in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id not in _ReadyToRunCache._submittable_id_datanodes[sequence.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[sequence.id]
-    assert dn_1.id not in _ReadyToRunCache._datanode_id_submittables
-    assert dn_2.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert sequence.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
-    assert _ReadyToRunCache._submittable_id_datanodes[sequence.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert sequence.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id not in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id not in _ReadyToRunProperty._submittable_id_datanodes[sequence.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[sequence.id]
+    assert dn_1.id not in _ReadyToRunProperty._datanode_id_submittables
+    assert dn_2.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert sequence.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_2.id] == {
+        f"DataNode {dn_2.id} is being edited"
+    }
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert sequence.id not in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_2.id not in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id not in _ReadyToRunCache._submittable_id_datanodes[sequence.id]
-    assert dn_2.id not in _ReadyToRunCache._datanode_id_submittables
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert sequence.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_2.id not in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id not in _ReadyToRunProperty._submittable_id_datanodes[sequence.id]
+    assert dn_2.id not in _ReadyToRunProperty._datanode_id_submittables
     assert _ScenarioManager._is_submittable(scenario)
     assert _SequenceManager._is_submittable(sequence)
     assert _SequenceManager._is_submittable(sequence.id)
@@ -556,6 +568,8 @@ def test_sequence_notification_subscribe(mocker):
             notify_1,
             notify_1,
             notify_1,
+            notify_1,
+            notify_2,
             notify_2,
             notify_2,
             notify_2,

tests/core/task/test_task_manager.py

@@ -18,12 +18,12 @@ import pytest
 from taipy.config.common.scope import Scope
 from taipy.config.config import Config
 from taipy.core import taipy
+from taipy.core._entity._ready_to_run_property import _ReadyToRunProperty
 from taipy.core._orchestrator._orchestrator import _Orchestrator
 from taipy.core._version._version_manager import _VersionManager
 from taipy.core.data._data_manager import _DataManager
 from taipy.core.data.in_memory import InMemoryDataNode
 from taipy.core.exceptions.exceptions import ModelNotFound, NonExistingTask
-from taipy.core.notification._ready_to_run_cache import _ReadyToRunCache
 from taipy.core.scenario._scenario_manager_factory import _ScenarioManagerFactory
 from taipy.core.task._task_manager import _TaskManager
 from taipy.core.task._task_manager_factory import _TaskManagerFactory
@@ -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 _ReadyToRunCache._submittable_id_datanodes
-    assert task.id not in _ReadyToRunCache._submittable_id_datanodes
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert task.id not in _ReadyToRunProperty._submittable_id_datanodes
     assert task_manager._is_submittable(task)
     assert task_manager._is_submittable(task.id)
     assert scenario_manager._is_submittable(scenario)
@@ -332,72 +332,78 @@ def test_is_submittable():
     assert not task_manager._is_submittable("Task_temp")
 
     dn_1.edit_in_progress = True
-    assert scenario.id in _ReadyToRunCache._submittable_id_datanodes
-    assert task.id in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[task.id]
-    assert dn_1.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert task.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
-    assert _ReadyToRunCache._submittable_id_datanodes[task.id][dn_1.id] == f"DataNode {dn_1.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert task.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[task.id]
+    assert dn_1.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert task.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_1.id] == {
+        f"DataNode {dn_1.id} is being edited"
+    }
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert task.id not in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id not in _ReadyToRunCache._datanode_id_submittables
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert task.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id not in _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert task.id in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id in _ReadyToRunCache._submittable_id_datanodes[task.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[task.id]
-    assert dn_1.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert task.id in _ReadyToRunCache._datanode_id_submittables[dn_1.id]
-    assert dn_2.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert task.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
-    assert _ReadyToRunCache._submittable_id_datanodes[task.id][dn_1.id] == f"DataNode {dn_1.id} is not written"
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
-    assert _ReadyToRunCache._submittable_id_datanodes[task.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert task.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id in _ReadyToRunProperty._submittable_id_datanodes[task.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[task.id]
+    assert dn_1.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert task.id in _ReadyToRunProperty._datanode_id_submittables[dn_1.id]
+    assert dn_2.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert task.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_1.id] == {f"DataNode {dn_1.id} is not written"}
+    assert _ReadyToRunProperty._submittable_id_datanodes[task.id][dn_1.id] == {f"DataNode {dn_1.id} is not written"}
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_2.id] == {
+        f"DataNode {dn_2.id} is being edited"
+    }
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert task.id in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_1.id not in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_1.id not in _ReadyToRunCache._submittable_id_datanodes[task.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id in _ReadyToRunCache._submittable_id_datanodes[task.id]
-    assert dn_1.id not in _ReadyToRunCache._datanode_id_submittables
-    assert dn_2.id in _ReadyToRunCache._datanode_id_submittables
-    assert scenario.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert task.id in _ReadyToRunCache._datanode_id_submittables[dn_2.id]
-    assert _ReadyToRunCache._submittable_id_datanodes[scenario.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
-    assert _ReadyToRunCache._submittable_id_datanodes[task.id][dn_2.id] == f"DataNode {dn_2.id} is being edited"
+    assert scenario.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert task.id in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_1.id not in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_1.id not in _ReadyToRunProperty._submittable_id_datanodes[task.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id in _ReadyToRunProperty._submittable_id_datanodes[task.id]
+    assert dn_1.id not in _ReadyToRunProperty._datanode_id_submittables
+    assert dn_2.id in _ReadyToRunProperty._datanode_id_submittables
+    assert scenario.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert task.id in _ReadyToRunProperty._datanode_id_submittables[dn_2.id]
+    assert _ReadyToRunProperty._submittable_id_datanodes[scenario.id][dn_2.id] == {
+        f"DataNode {dn_2.id} is being edited"
+    }
+    assert _ReadyToRunProperty._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 _ReadyToRunCache._submittable_id_datanodes
-    assert task.id not in _ReadyToRunCache._submittable_id_datanodes
-    assert dn_2.id not in _ReadyToRunCache._submittable_id_datanodes[scenario.id]
-    assert dn_2.id not in _ReadyToRunCache._submittable_id_datanodes[task.id]
-    assert dn_2.id not in _ReadyToRunCache._datanode_id_submittables
+    assert scenario.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert task.id not in _ReadyToRunProperty._submittable_id_datanodes
+    assert dn_2.id not in _ReadyToRunProperty._submittable_id_datanodes[scenario.id]
+    assert dn_2.id not in _ReadyToRunProperty._submittable_id_datanodes[task.id]
+    assert dn_2.id not in _ReadyToRunProperty._datanode_id_submittables
     assert scenario_manager._is_submittable(scenario)
     assert task_manager._is_submittable(task)
     assert task_manager._is_submittable(task.id)