added test

taipy/core/job/_job_manager.py

@@ -94,12 +94,11 @@ class _JobManager(_Manager[Job], _VersionMixin):
         if isinstance(job, str):
             job_id = job
             job = cls._get(job, None)
-        else:
-            job_id = job.id
+            if job is None:
+                reason_collector._add_reason(job_id, EntityDoesNotExist(job_id))
+                return reason_collector
 
-        if job is None:
-            reason_collector._add_reason(job_id, EntityDoesNotExist(job_id))
-        elif not job.is_finished():
+        if not job.is_finished():
             reason_collector._add_reason(job.id, JobIsNotFinished(job.id))
 
         return reason_collector

taipy/core/reason/__init__.py

@@ -26,6 +26,7 @@ from .reason import (
     DataNodeEditInProgress,
     DataNodeIsNotWritten,
     EntityDoesNotExist,
+    EntityIsNotAScenario,
     EntityIsNotSubmittableEntity,
     InvalidUploadFile,
     JobIsNotFinished,

taipy/core/reason/reason.py

@@ -151,8 +151,9 @@ class NoFileToDownload(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, file_path: str, datanode_id: str):
-        Reason.__init__(self, f"Path '{file_path}' from data node '{datanode_id}'"
-                              f" does not exist and cannot be downloaded.")
+        Reason.__init__(
+            self, f"Path '{file_path}' from data node '{datanode_id}'" f" does not exist and cannot be downloaded"
+        )
         _DataNodeReasonMixin.__init__(self, datanode_id)
 
 
@@ -165,8 +166,9 @@ class NotAFile(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, file_path: str, datanode_id: str):
-        Reason.__init__(self, f"Path '{file_path}' from data node '{datanode_id}'"
-                              f" is not a file and can t be downloaded.")
+        Reason.__init__(
+            self, f"Path '{file_path}' from data node '{datanode_id}'" f" is not a file and can t be downloaded"
+        )
         _DataNodeReasonMixin.__init__(self, datanode_id)
 
 
@@ -193,7 +195,7 @@ class EntityDoesNotExist(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, entity_id: str):
-        Reason.__init__(self, f"Entity {entity_id} does not exist in the repository.")
+        Reason.__init__(self, f"Entity {entity_id} does not exist in the repository")
 
 
 class JobIsNotFinished(Reason, _DataNodeReasonMixin):
@@ -205,7 +207,19 @@ class JobIsNotFinished(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, job_id: str):
-        Reason.__init__(self, f"The job {job_id} is not finished yet.")
+        Reason.__init__(self, f"The job {job_id} is not finished yet")
+
+
+class EntityIsNotAScenario(Reason, _DataNodeReasonMixin):
+    """
+    The entity is not a scenario, which prevents specific actions from being performed.
+
+    Attributes:
+        entity_id (str): The entity identifier.
+    """
+
+    def __init__(self, entity_id: str):
+        Reason.__init__(self, f"The entity {entity_id} is not a scenario")
 
 
 class ScenarioIsThePrimaryScenario(Reason, _DataNodeReasonMixin):
@@ -218,7 +232,7 @@ class ScenarioIsThePrimaryScenario(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, scenario_id: str, cycle: str):
-        Reason.__init__(self, f"The scenario {scenario_id} is the primary scenario of cycle {cycle}.")
+        Reason.__init__(self, f"The scenario {scenario_id} is the primary scenario of cycle {cycle}")
 
 
 class ScenarioDoesNotBelongToACycle(Reason, _DataNodeReasonMixin):
@@ -230,7 +244,7 @@ class ScenarioDoesNotBelongToACycle(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, scenario_id: str):
-        Reason.__init__(self, f"The scenario {scenario_id} does not belong to any cycle.")
+        Reason.__init__(self, f"The scenario {scenario_id} does not belong to any cycle")
 
 
 class SubmissionIsNotFinished(Reason, _DataNodeReasonMixin):
@@ -242,7 +256,7 @@ class SubmissionIsNotFinished(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, submission_id: str):
-        Reason.__init__(self, f"The submission {submission_id} is not finished yet.")
+        Reason.__init__(self, f"The submission {submission_id} is not finished yet")
 
 
 class SubmissionStatusIsUndefined(Reason, _DataNodeReasonMixin):
@@ -254,4 +268,4 @@ class SubmissionStatusIsUndefined(Reason, _DataNodeReasonMixin):
     """
 
     def __init__(self, submission_id: str):
-        Reason.__init__(self, f"The status of submission {submission_id} is undefined.")
+        Reason.__init__(self, f"The status of submission {submission_id} is undefined")

taipy/core/scenario/_scenario_manager.py

@@ -41,6 +41,7 @@ from ..job.job import Job
 from ..notification import EventEntityType, EventOperation, Notifier, _make_event
 from ..reason import (
     EntityDoesNotExist,
+    EntityIsNotAScenario,
     EntityIsNotSubmittableEntity,
     ReasonCollection,
     ScenarioDoesNotBelongToACycle,
@@ -208,17 +209,17 @@ class _ScenarioManager(_Manager[Scenario], _VersionMixin):
 
     @classmethod
     def _is_submittable(cls, scenario: Union[Scenario, ScenarioId]) -> ReasonCollection:
+        reason_collector = ReasonCollection()
+
         if isinstance(scenario, str):
             scenario_id = scenario
             scenario = cls._get(scenario)
-        else:
-            scenario_id = scenario.id
+            if scenario is None:
+                reason_collector._add_reason(scenario_id, EntityDoesNotExist(scenario_id))
+                return reason_collector
 
-        reason_collector = ReasonCollection()
-        if scenario is None:
-            reason_collector._add_reason(scenario_id, EntityDoesNotExist(scenario_id))
-        elif not isinstance(scenario, Scenario):
-            reason_collector._add_reason(scenario_id, EntityIsNotSubmittableEntity(scenario_id))
+        if not isinstance(scenario, Scenario):
+            reason_collector._add_reason(str(scenario), EntityIsNotSubmittableEntity(str(scenario)))
         else:
             return scenario.is_ready_to_run()
 
@@ -432,14 +433,16 @@ class _ScenarioManager(_Manager[Scenario], _VersionMixin):
         if isinstance(scenario, str):
             scenario_id = scenario
             scenario = cls._get(scenario)
-        else:
-            scenario_id = scenario.id
+            if scenario is None:
+                reason_collection._add_reason(scenario_id, EntityDoesNotExist(scenario_id))
+                return reason_collection
 
-        if scenario is None:
-            reason_collection._add_reason(scenario_id, EntityDoesNotExist(scenario_id))
+        if not isinstance(scenario, Scenario):
+            reason_collection._add_reason(str(scenario), EntityIsNotAScenario(str(scenario)))
         elif scenario.is_primary:
             if len(cls._get_all_by_cycle(scenario.cycle)) > 1:
                 reason_collection._add_reason(scenario.id, ScenarioIsThePrimaryScenario(scenario.id, scenario.cycle.id))
+
         return reason_collection
 
     @classmethod

taipy/core/sequence/_sequence_manager.py

@@ -342,17 +342,17 @@ class _SequenceManager(_Manager[Sequence], _VersionMixin):
 
     @classmethod
     def _is_submittable(cls, sequence: Union[Sequence, SequenceId]) -> ReasonCollection:
+        reason_collector = ReasonCollection()
+
         if isinstance(sequence, str):
             sequence_id = sequence
             sequence = cls._get(sequence)
-        else:
-            sequence_id = sequence.id
+            if sequence is None:
+                reason_collector._add_reason(sequence_id, EntityDoesNotExist(sequence_id))
+                return reason_collector
 
-        reason_collector = ReasonCollection()
-        if sequence is None:
-            reason_collector._add_reason(sequence_id, EntityDoesNotExist(sequence_id))
-        elif not isinstance(sequence, Sequence):
-            reason_collector._add_reason(sequence_id, EntityIsNotSubmittableEntity(sequence_id))
+        if not isinstance(sequence, Sequence):
+            reason_collector._add_reason(str(sequence), EntityIsNotSubmittableEntity(str(sequence)))
         else:
             return sequence.is_ready_to_run()
 

taipy/core/submission/_submission_manager.py

@@ -180,12 +180,11 @@ class _SubmissionManager(_Manager[Submission], _VersionMixin):
         if isinstance(submission, str):
             submission_id = submission
             submission = cls._get(submission)
-        else:
-            submission_id = submission.id
+            if submission is None:
+                reason_collector._add_reason(submission_id, EntityDoesNotExist(submission_id))
+                return reason_collector
 
-        if submission is None:
-            reason_collector._add_reason(submission_id, EntityDoesNotExist(submission_id))
-        elif not submission.is_finished() and submission.submission_status != SubmissionStatus.UNDEFINED:
-            reason_collector._add_reason(submission_id, SubmissionIsNotFinished(submission_id))
+        if not submission.is_finished() and submission.submission_status != SubmissionStatus.UNDEFINED:
+            reason_collector._add_reason(submission.id, SubmissionIsNotFinished(submission.id))
 
         return reason_collector

taipy/core/task/_task_manager.py

@@ -171,18 +171,16 @@ class _TaskManager(_Manager[Task], _VersionMixin):
 
     @classmethod
     def _is_submittable(cls, task: Union[Task, TaskId]) -> ReasonCollection:
+        reason_collection = ReasonCollection()
+
         if isinstance(task, str):
             task_id = task
             task = cls._get(task)
-        else:
-            task_id = task.id
+            if task is None:
+                reason_collection._add_reason(task_id, EntityDoesNotExist(task_id))
 
-        reason_collection = ReasonCollection()
-        if task is None:
-            reason_collection._add_reason(task_id, EntityDoesNotExist(task_id))
-        elif not isinstance(task, Task):
-            task = str(task)
-            reason_collection._add_reason(task, EntityIsNotSubmittableEntity(task))
+        if not isinstance(task, Task):
+            reason_collection._add_reason(str(task), EntityIsNotSubmittableEntity(str(task)))
         else:
             data_manager = _DataManagerFactory._build_manager()
             for node in task.input.values():

tests/core/job/test_job_manager.py

@@ -412,6 +412,10 @@ def test_is_deletable():
     task = _create_task(print, 0, "task")
     job = _OrchestratorFactory._orchestrator.submit_task(task).jobs[0]
 
+    rc = _JobManager._is_deletable("some_job")
+    assert not rc
+    assert "Entity some_job does not exist in the repository." in rc.reasons
+
     assert job.is_completed()
     assert _JobManager._is_deletable(job)
     assert _JobManager._is_deletable(job.id)

tests/core/scenario/test_scenario_manager.py

@@ -404,6 +404,10 @@ def test_is_deletable():
     scenario_1_primary = _ScenarioManager._create(scenario_config, creation_date=creation_date, name="1")
     scenario_2 = _ScenarioManager._create(scenario_config, creation_date=creation_date, name="2")
 
+    rc = _ScenarioManager._is_deletable("some_scenario")
+    assert not rc
+    assert "Entity some_scenario does not exist in the repository." in rc.reasons
+
     assert len(_ScenarioManager._get_all()) == 2
     assert scenario_1_primary.is_primary
     assert not _ScenarioManager._is_deletable(scenario_1_primary)
@@ -681,12 +685,10 @@ def notify_multi_param(param, *args):
     assert len(param) == 3
 
 
-def notify1(*args, **kwargs):
-    ...
+def notify1(*args, **kwargs): ...
 
 
-def notify2(*args, **kwargs):
-    ...
+def notify2(*args, **kwargs): ...
 
 
 def test_notification_unsubscribe(mocker):
@@ -1045,6 +1047,10 @@ def test_is_submittable():
     scenario_config = Config.configure_scenario("sc", {task_config}, set(), Frequency.DAILY)
     scenario = _ScenarioManager._create(scenario_config)
 
+    rc = _ScenarioManager._is_submittable("some_scenario")
+    assert not rc
+    assert "Entity some_scenario does not exist in the repository." in rc.reasons
+
     assert len(_ScenarioManager._get_all()) == 1
     assert _ScenarioManager._is_submittable(scenario)
     assert _ScenarioManager._is_submittable(scenario.id)

tests/core/sequence/test_sequence_manager.py

@@ -206,6 +206,10 @@ def test_is_submittable():
     scenario = Scenario("scenario", {task}, {}, set())
     _ScenarioManager._set(scenario)
 
+    rc = _SequenceManager._is_submittable("some_sequence")
+    assert not rc
+    assert "Entity some_sequence does not exist in the repository." in rc.reasons
+
     scenario.add_sequences({"sequence": [task]})
     sequence = scenario.sequences["sequence"]
 
@@ -445,16 +449,13 @@ def test_get_or_create_data():
         sequence.WRONG.write(7)
 
 
-def notify1(*args, **kwargs):
-    ...
+def notify1(*args, **kwargs): ...
 
 
-def notify2(*args, **kwargs):
-    ...
+def notify2(*args, **kwargs): ...
 
 
-def notify_multi_param(*args, **kwargs):
-    ...
+def notify_multi_param(*args, **kwargs): ...
 
 
 def test_sequence_notification_subscribe(mocker):

tests/core/submission/test_submission_manager.py

@@ -151,6 +151,10 @@ def test_is_deletable():
 
     assert len(submission_manager._get_all()) == 1
 
+    rc = submission_manager._is_deletable("some_submission")
+    assert not rc
+    assert "Entity some_submission does not exist in the repository." in rc.reasons
+
     assert submission._submission_status == SubmissionStatus.SUBMITTED
     assert not submission.is_deletable()
     assert not submission_manager._is_deletable(submission)

tests/core/task/test_task_manager.py

@@ -308,6 +308,10 @@ def test_is_submittable():
     task_config = Config.configure_task("task", print, [dn_config])
     task = _TaskManager._bulk_get_or_create([task_config])[0]
 
+    rc = _TaskManager._is_submittable("some_task")
+    assert not rc
+    assert "Entity some_task does not exist in the repository" in rc.reasons
+
     assert len(_TaskManager._get_all()) == 1
     assert _TaskManager._is_submittable(task)
     assert _TaskManager._is_submittable(task.id)