refactor: build enterprise managers alongside community managers in the _Reloader class

taipy/core/_entity/_entity.py

@@ -11,7 +11,7 @@
 
 from typing import List
 
-from .._entity._reload import _get_manager
+from .._entity._reload import _Reloader
 from ..notification import Notifier
 
 
@@ -33,8 +33,8 @@ class _Entity:
             for to_delete_key in self._properties._pending_deletions:
                 self._properties.data.pop(to_delete_key, None)
             self._properties.data.update(self._properties._pending_changes)
-        _get_manager(self._MANAGER_NAME)._set(self)
+        _Reloader._get_manager(self._MANAGER_NAME)._set(self)
 
         for event in self._in_context_attributes_changed_collector:
             Notifier.publish(event)
-        _get_manager(self._MANAGER_NAME)._set(self)
+        _Reloader._get_manager(self._MANAGER_NAME)._set(self)

taipy/core/_entity/_reload.py

@@ -10,6 +10,7 @@
 # specific language governing permissions and limitations under the License.
 
 import functools
+from typing import Dict
 
 from .._manager._manager import _Manager
 from ..common._check_dependencies import EnterpriseEditionUtils
@@ -21,19 +22,21 @@ class _Reloader:
     """The _Reloader singleton class"""
 
     _instance = None
-
     _no_reload_context = False
 
+    _managers: Dict[str, _Manager] = {}
+
     def __new__(cls, *args, **kwargs):
         if not isinstance(cls._instance, cls):
             cls._instance = object.__new__(cls, *args, **kwargs)
+            cls._managers = cls._build_managers()
         return cls._instance
 
     def _reload(self, manager: str, obj):
         if self._no_reload_context:
             return obj
 
-        entity = _get_manager(manager)._get(obj, obj)
+        entity = self._get_manager(manager)._get(obj, obj)
         if obj._is_in_context and hasattr(entity, "_properties"):
             if obj._properties._pending_changes:
                 entity._properties._pending_changes = obj._properties._pending_changes
@@ -49,6 +52,40 @@ class _Reloader:
     def __exit__(self, exc_type, exc_value, exc_traceback):
         self._no_reload_context = False
 
+    @classmethod
+    @functools.lru_cache
+    def _build_managers(cls) -> Dict[str, _Manager]:
+        from ..cycle._cycle_manager_factory import _CycleManagerFactory
+        from ..data._data_manager_factory import _DataManagerFactory
+        from ..job._job_manager_factory import _JobManagerFactory
+        from ..scenario._scenario_manager_factory import _ScenarioManagerFactory
+        from ..sequence._sequence_manager_factory import _SequenceManagerFactory
+        from ..submission._submission_manager_factory import _SubmissionManagerFactory
+        from ..task._task_manager_factory import _TaskManagerFactory
+
+        managers = {
+            "scenario": _ScenarioManagerFactory._build_manager(),
+            "sequence": _SequenceManagerFactory._build_manager(),
+            "data": _DataManagerFactory._build_manager(),
+            "cycle": _CycleManagerFactory._build_manager(),
+            "job": _JobManagerFactory._build_manager(),
+            "task": _TaskManagerFactory._build_manager(),
+            "submission": _SubmissionManagerFactory._build_manager(),
+        }
+
+        if EnterpriseEditionUtils._using_enterprise():
+            _build_enterprise_managers = _load_fct(
+                EnterpriseEditionUtils._TAIPY_ENTERPRISE_CORE_MODULE + "._entity.utils", "_build_enterprise_managers"
+            )
+            managers.update(_build_enterprise_managers())
+
+        return managers
+
+    @classmethod
+    @functools.lru_cache
+    def _get_manager(cls, manager: str) -> _Manager:
+        return cls._managers[manager]
+
 
 def _self_reload(manager: str):
     def __reload(fct):
@@ -67,7 +104,7 @@ def _self_setter(manager):
         @functools.wraps(fct)
         def _do_set_entity(self, *args, **kwargs):
             fct(self, *args, **kwargs)
-            entity_manager = _get_manager(manager)
+            entity_manager = _Reloader._get_manager(manager)
             value = args[0] if len(args) == 1 else args
             event = _make_event(
                 self,
@@ -86,32 +123,3 @@ def _self_setter(manager):
         return _do_set_entity
 
     return __set_entity
-
-
-@functools.lru_cache
-def _get_manager(manager: str) -> _Manager:
-    from ..cycle._cycle_manager_factory import _CycleManagerFactory
-    from ..data._data_manager_factory import _DataManagerFactory
-    from ..job._job_manager_factory import _JobManagerFactory
-    from ..scenario._scenario_manager_factory import _ScenarioManagerFactory
-    from ..sequence._sequence_manager_factory import _SequenceManagerFactory
-    from ..submission._submission_manager_factory import _SubmissionManagerFactory
-    from ..task._task_manager_factory import _TaskManagerFactory
-
-    managers = {
-        "scenario": _ScenarioManagerFactory._build_manager(),
-        "sequence": _SequenceManagerFactory._build_manager(),
-        "data": _DataManagerFactory._build_manager(),
-        "cycle": _CycleManagerFactory._build_manager(),
-        "job": _JobManagerFactory._build_manager(),
-        "task": _TaskManagerFactory._build_manager(),
-        "submission": _SubmissionManagerFactory._build_manager(),
-    }
-
-    if EnterpriseEditionUtils._using_enterprise():
-        _build_user_manager = _load_fct(
-            EnterpriseEditionUtils._TAIPY_AUTH_MODULE + ".user._user_manager_factory", "_UserManagerFactory"
-        )._build_manager
-        managers["user"] = _build_user_manager()
-
-    return managers[manager]

taipy/core/common/_check_dependencies.py

@@ -32,7 +32,6 @@ def _check_dependency_is_installed(module_name: str, package_name: str) -> None:
 
 
 class EnterpriseEditionUtils:
-    _TAIPY_AUTH_MODULE = "taipy.auth"
     _TAIPY_ENTERPRISE_MODULE = "taipy.enterprise"
     _TAIPY_ENTERPRISE_CORE_MODULE = _TAIPY_ENTERPRISE_MODULE + ".core"