feat: can_create() accept the config as an optional parameter

taipy/core/data/_data_manager.py

@@ -71,14 +71,15 @@ class _DataManager(_Manager[DataNode], _VersionMixin):
         }
 
     @classmethod
-    def _can_create(cls, config: DataNodeConfig) -> Reasons:
+    def _can_create(cls, config: Optional[DataNodeConfig] = None) -> Reasons:
         config_id = getattr(config, "id", None) or str(config)
         reason = Reasons(config_id)
 
-        if not isinstance(config, DataNodeConfig):
-            reason._add_reason(config_id, _build_wrong_config_type_reason(config_id))
-        elif config.scope is not Scope.GLOBAL:
-            reason._add_reason(config_id, _build_not_global_scope_reason(config_id))
+        if config is not None:
+            if not isinstance(config, DataNodeConfig):
+                reason._add_reason(config_id, _build_wrong_config_type_reason(config_id, "DataNodeConfig"))
+            elif config.scope is not Scope.GLOBAL:
+                reason._add_reason(config_id, _build_not_global_scope_reason(config_id))
 
         return reason
 

taipy/core/reason/_reason_factory.py

@@ -9,6 +9,8 @@
 # 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 typing import Optional
+
 from ..data.data_node import DataNodeId
 
 
@@ -24,7 +26,10 @@ def _build_not_submittable_entity_reason(entity_id: str) -> str:
     return f"Entity {entity_id} is not a submittable entity"
 
 
-def _build_wrong_config_type_reason(config_id: str) -> str:
+def _build_wrong_config_type_reason(config_id: str, config_type: Optional[str]) -> str:
+    if config_type:
+        return f'Object "{config_id}" must be a valid {config_type}'
+
     return f'Object "{config_id}" is not a valid config to be created'
 
 

taipy/core/scenario/_scenario_manager.py

@@ -115,12 +115,13 @@ class _ScenarioManager(_Manager[Scenario], _VersionMixin):
         )
 
     @classmethod
-    def _can_create(cls, config: ScenarioConfig) -> Reasons:
+    def _can_create(cls, config: Optional[ScenarioConfig] = None) -> Reasons:
         config_id = getattr(config, "id", None) or str(config)
         reason = Reasons(config_id)
 
-        if not isinstance(config, ScenarioConfig):
-            reason._add_reason(config_id, _build_wrong_config_type_reason(config_id))
+        if config is not None:
+            if not isinstance(config, ScenarioConfig):
+                reason._add_reason(config_id, _build_wrong_config_type_reason(config_id, "ScenarioConfig"))
 
         return reason
 

taipy/core/taipy.py

@@ -51,7 +51,7 @@ from .exceptions.exceptions import (
 from .job._job_manager_factory import _JobManagerFactory
 from .job.job import Job
 from .job.job_id import JobId
-from .reason._reason_factory import _build_not_submittable_entity_reason, _build_wrong_config_type_reason
+from .reason._reason_factory import _build_not_submittable_entity_reason
 from .reason.reason import Reasons
 from .scenario._scenario_manager_factory import _ScenarioManagerFactory
 from .scenario.scenario import Scenario
@@ -873,21 +873,18 @@ def get_cycles() -> List[Cycle]:
     return _CycleManagerFactory._build_manager()._get_all()
 
 
-def can_create(config: Union[ScenarioConfig, DataNodeConfig]) -> Reasons:
-    """Indicate if a config can be created.
+def can_create(config: Optional[Union[ScenarioConfig, DataNodeConfig]] = None) -> Reasons:
+    """Indicate if a config can be created. The config should be a scenario or data node config.
 
-    This function checks if the given scenario or data node config can be created.
+    If no config is provided, the function indicates if any scenario or data node config can be created.
 
     Returns:
         True if the given config can be created. False otherwise.
     """
-    if isinstance(config, ScenarioConfig):
-        return _ScenarioManagerFactory._build_manager()._can_create(config)
-    elif isinstance(config, DataNodeConfig):
+    if isinstance(config, DataNodeConfig):
         return _DataManagerFactory._build_manager()._can_create(config)
-    else:
-        config_id = getattr(config, "id", None) or str(config)
-        return Reasons(config_id)._add_reason(config_id, _build_wrong_config_type_reason(config_id))
+
+    return _ScenarioManagerFactory._build_manager()._can_create(config)
 
 
 def create_scenario(

tests/core/data/test_data_manager.py

@@ -46,11 +46,15 @@ class TestDataManager:
         assert dn.properties.get("baz") == "qux"
 
     def test_can_create(self):
-        dn_config = Config.configure_in_memory_data_node("dn", 10, scope=Scope.SCENARIO)
+        dn_config = Config.configure_data_node("dn", 10, scope=Scope.SCENARIO)
         global_dn_config = Config.configure_data_node(
             id="global_dn", storage_type="in_memory", scope=Scope.GLOBAL, data=10
         )
 
+        reasons = _DataManager._can_create()
+        assert bool(reasons) is True
+        assert reasons._reasons == {}
+
         reasons = _DataManager._can_create(global_dn_config)
         assert bool(reasons) is True
         assert reasons._reasons == {}
@@ -61,7 +65,7 @@ class TestDataManager:
 
         reasons = _DataManager._can_create(1)
         assert bool(reasons) is False
-        assert reasons._reasons == {"1": {'Object "1" is not a valid config to be created'}}
+        assert reasons._reasons == {"1": {'Object "1" must be a valid DataNodeConfig'}}
 
     def test_create_data_node_with_name_provided(self):
         dn_config = Config.configure_data_node(id="dn", foo="bar", name="acb")

tests/core/scenario/test_scenario_manager.py

@@ -370,6 +370,10 @@ def test_can_create():
     task_config = Config.configure_task("task", print, [dn_config])
     scenario_config = Config.configure_scenario("sc", {task_config}, [], Frequency.DAILY)
 
+    reasons = _ScenarioManager._can_create()
+    assert bool(reasons) is True
+    assert reasons._reasons == {}
+
     reasons = _ScenarioManager._can_create(scenario_config)
     assert bool(reasons) is True
     assert reasons._reasons == {}
@@ -377,13 +381,13 @@ def test_can_create():
 
     reasons = _ScenarioManager._can_create(task_config)
     assert bool(reasons) is False
-    assert reasons._reasons == {task_config.id: {'Object "task" is not a valid config to be created'}}
+    assert reasons._reasons == {task_config.id: {'Object "task" must be a valid ScenarioConfig'}}
     with pytest.raises(AttributeError):
         _ScenarioManager._create(task_config)
 
     reasons = _ScenarioManager._can_create(1)
     assert bool(reasons) is False
-    assert reasons._reasons == {"1": {'Object "1" is not a valid config to be created'}}
+    assert reasons._reasons == {"1": {'Object "1" must be a valid ScenarioConfig'}}
     with pytest.raises(AttributeError):
         _ScenarioManager._create(1)
 

tests/core/test_taipy.py

@@ -683,6 +683,7 @@ class TestTaipy:
         task_config = Config.configure_task("task", print, [dn_config])
         scenario_config = Config.configure_scenario("sc", {task_config}, [], Frequency.DAILY)
 
+        assert tp.can_create()
         assert tp.can_create(scenario_config)
         assert tp.can_create(global_dn_config)
         assert not tp.can_create(dn_config)