added checking if entity exists

taipy/core/job/_job_manager.py

@@ -18,7 +18,7 @@ from .._version._version_manager_factory import _VersionManagerFactory
 from .._version._version_mixin import _VersionMixin
 from ..exceptions.exceptions import JobNotDeletedException
 from ..notification import EventEntityType, EventOperation, Notifier, _make_event
-from ..reason import JobIsNotFinished, ReasonCollection
+from ..reason import EntityDoesNotExist, JobIsNotFinished, ReasonCollection
 from ..task.task import Task
 from .job import Job
 from .job_id import JobId
@@ -92,9 +92,14 @@ class _JobManager(_Manager[Job], _VersionMixin):
         reason_collector = ReasonCollection()
 
         if isinstance(job, str):
-            job = cls._get(job)
+            job_id = job
+            job = cls._get(job, None)
+        else:
+            job_id = job.id
 
-        if job and not job.is_finished():
+        if job is None:
+            reason_collector._add_reason(job_id, EntityDoesNotExist(job_id))
+        elif not job.is_finished():
             reason_collector._add_reason(job.id, JobIsNotFinished(job.id))
 
         return reason_collector

taipy/core/scenario/_scenario_manager.py

@@ -209,15 +209,20 @@ class _ScenarioManager(_Manager[Scenario], _VersionMixin):
     @classmethod
     def _is_submittable(cls, scenario: Union[Scenario, ScenarioId]) -> ReasonCollection:
         if isinstance(scenario, str):
+            scenario_id = scenario
             scenario = cls._get(scenario)
+        else:
+            scenario_id = scenario.id
 
-        if not isinstance(scenario, Scenario):
-            scenario = str(scenario)
-            reason_collector = ReasonCollection()
-            reason_collector._add_reason(scenario, EntityIsNotSubmittableEntity(scenario))
-            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))
+        else:
+            return scenario.is_ready_to_run()
 
-        return scenario.is_ready_to_run()
+        return reason_collector
 
     @classmethod
     def _submit(
@@ -425,8 +430,14 @@ class _ScenarioManager(_Manager[Scenario], _VersionMixin):
         reason_collection = ReasonCollection()
 
         if isinstance(scenario, str):
+            scenario_id = scenario
             scenario = cls._get(scenario)
-        if scenario.is_primary:
+        else:
+            scenario_id = scenario.id
+
+        if scenario is None:
+            reason_collection._add_reason(scenario_id, EntityDoesNotExist(scenario_id))
+        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

taipy/core/sequence/_sequence_manager.py

@@ -343,15 +343,20 @@ class _SequenceManager(_Manager[Sequence], _VersionMixin):
     @classmethod
     def _is_submittable(cls, sequence: Union[Sequence, SequenceId]) -> ReasonCollection:
         if isinstance(sequence, str):
+            sequence_id = sequence
             sequence = cls._get(sequence)
+        else:
+            sequence_id = sequence.id
 
-        if not isinstance(sequence, Sequence):
-            sequence = str(sequence)
-            reason_collector = ReasonCollection()
-            reason_collector._add_reason(sequence, EntityIsNotSubmittableEntity(sequence))
-            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))
+        else:
+            return sequence.is_ready_to_run()
 
-        return sequence.is_ready_to_run()
+        return reason_collector
 
     @classmethod
     def _submit(

taipy/core/submission/_submission_manager.py

@@ -21,7 +21,7 @@ from .._version._version_mixin import _VersionMixin
 from ..exceptions.exceptions import SubmissionNotDeletedException
 from ..job.job import Job, Status
 from ..notification import EventEntityType, EventOperation, Notifier, _make_event
-from ..reason import ReasonCollection, SubmissionIsNotFinished
+from ..reason import EntityDoesNotExist, ReasonCollection, SubmissionIsNotFinished
 from ..scenario.scenario import Scenario
 from ..sequence.sequence import Sequence
 from ..submission.submission import Submission, SubmissionId, SubmissionStatus
@@ -178,9 +178,14 @@ class _SubmissionManager(_Manager[Submission], _VersionMixin):
         reason_collector = ReasonCollection()
 
         if isinstance(submission, str):
+            submission_id = submission
             submission = cls._get(submission)
+        else:
+            submission_id = submission.id
 
-        if not submission.is_finished() and submission.submission_status != SubmissionStatus.UNDEFINED:
-            reason_collector._add_reason(submission.id, SubmissionIsNotFinished(submission.id))
+        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))
 
         return reason_collector

taipy/core/task/_task_manager.py

@@ -26,7 +26,13 @@ from ..cycle.cycle_id import CycleId
 from ..data._data_manager_factory import _DataManagerFactory
 from ..exceptions.exceptions import NonExistingTask
 from ..notification import EventEntityType, EventOperation, Notifier, _make_event
-from ..reason import DataNodeEditInProgress, DataNodeIsNotWritten, EntityIsNotSubmittableEntity, ReasonCollection
+from ..reason import (
+    DataNodeEditInProgress,
+    DataNodeIsNotWritten,
+    EntityDoesNotExist,
+    EntityIsNotSubmittableEntity,
+    ReasonCollection,
+)
 from ..scenario.scenario_id import ScenarioId
 from ..sequence.sequence_id import SequenceId
 from ..submission.submission import Submission
@@ -166,10 +172,15 @@ class _TaskManager(_Manager[Task], _VersionMixin):
     @classmethod
     def _is_submittable(cls, task: Union[Task, TaskId]) -> ReasonCollection:
         if isinstance(task, str):
+            task_id = task
             task = cls._get(task)
+        else:
+            task_id = task.id
 
         reason_collection = ReasonCollection()
-        if not isinstance(task, Task):
+        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))
         else: