fix: mypy errors

taipy/core/_version/_version_manager.py

@@ -238,7 +238,7 @@ class _VersionManager(_Manager[_Version]):
 
         comparator_result = Config._comparator._find_conflict_config(  # type: ignore[attr-defined]
             imported_version.config,
-            Config._applied_config,
+            Config._applied_config,  # type: ignore[attr-defined]
             imported_version.id,
         )
         if comparator_result.get(_ComparatorResult.CONFLICTED_SECTION_KEY):

taipy/core/_version/_version_manager_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 Type
+
 from .._manager._manager_factory import _ManagerFactory
 from ..common import _utils
 from ._version_fs_repository import _VersionFSRepository
@@ -17,11 +19,10 @@ from ._version_sql_repository import _VersionSQLRepository
 
 
 class _VersionManagerFactory(_ManagerFactory):
-
     __REPOSITORY_MAP = {"default": _VersionFSRepository, "sql": _VersionSQLRepository}
 
     @classmethod
-    def _build_manager(cls) -> _VersionManager:  # type: ignore
+    def _build_manager(cls) -> Type[_VersionManager]:
         if cls._using_enterprise():
             version_manager = _utils._load_fct(
                 cls._TAIPY_ENTERPRISE_CORE_MODULE + "._version._version_manager", "_VersionManager"

taipy/core/cycle/_cycle_manager_factory.py

@@ -19,11 +19,10 @@ from ._cycle_sql_repository import _CycleSQLRepository
 
 
 class _CycleManagerFactory(_ManagerFactory):
-
     __REPOSITORY_MAP = {"default": _CycleFSRepository, "sql": _CycleSQLRepository}
 
     @classmethod
-    def _build_manager(cls) -> Type[_CycleManager]:  # type: ignore
+    def _build_manager(cls) -> Type[_CycleManager]:
         if cls._using_enterprise():
             cycle_manager = _load_fct(
                 cls._TAIPY_ENTERPRISE_CORE_MODULE + ".cycle._cycle_manager", "_CycleManager"

taipy/core/data/_data_manager_factory.py

@@ -19,11 +19,10 @@ from ._data_sql_repository import _DataSQLRepository
 
 
 class _DataManagerFactory(_ManagerFactory):
-
     __REPOSITORY_MAP = {"default": _DataFSRepository, "sql": _DataSQLRepository}
 
     @classmethod
-    def _build_manager(cls) -> Type[_DataManager]:  # type: ignore
+    def _build_manager(cls) -> Type[_DataManager]:
         if cls._using_enterprise():
             data_manager = _load_fct(
                 cls._TAIPY_ENTERPRISE_CORE_MODULE + ".data._data_manager", "_DataManager"

taipy/core/job/_job_manager_factory.py

@@ -19,11 +19,10 @@ from ._job_sql_repository import _JobSQLRepository
 
 
 class _JobManagerFactory(_ManagerFactory):
-
     __REPOSITORY_MAP = {"default": _JobFSRepository, "sql": _JobSQLRepository}
 
     @classmethod
-    def _build_manager(cls) -> Type[_JobManager]:  # type: ignore
+    def _build_manager(cls) -> Type[_JobManager]:
         if cls._using_enterprise():
             job_manager = _load_fct(
                 cls._TAIPY_ENTERPRISE_CORE_MODULE + ".job._job_manager", "_JobManager"

taipy/core/scenario/_scenario_manager.py

@@ -14,7 +14,7 @@ import pathlib
 import tempfile
 import zipfile
 from functools import partial
-from typing import Any, Callable, Dict, List, Literal, Optional, Union
+from typing import Any, Callable, Dict, List, Literal, Optional, Type, Union
 
 from taipy.config import Config
 
@@ -463,7 +463,7 @@ class _ScenarioManager(_Manager[Scenario], _VersionMixin):
         cls,
         zip_file_path: pathlib.Path,
         override: bool,
-        entity_managers: Dict[str, _Manager],
+        entity_managers: Dict[str, Type[_Manager]],
     ) -> Optional[Scenario]:
         with tempfile.TemporaryDirectory() as tmp_dir:
             with zipfile.ZipFile(zip_file_path) as zip_file:

taipy/core/scenario/_scenario_manager_factory.py

@@ -19,11 +19,10 @@ from ._scenario_sql_repository import _ScenarioSQLRepository
 
 
 class _ScenarioManagerFactory(_ManagerFactory):
-
     __REPOSITORY_MAP = {"default": _ScenarioFSRepository, "sql": _ScenarioSQLRepository}
 
     @classmethod
-    def _build_manager(cls) -> Type[_ScenarioManager]:  # type: ignore
+    def _build_manager(cls) -> Type[_ScenarioManager]:
         if cls._using_enterprise():
             scenario_manager = _load_fct(
                 cls._TAIPY_ENTERPRISE_CORE_MODULE + ".scenario._scenario_manager", "_ScenarioManager"

taipy/core/submission/_submission_manager_factory.py

@@ -19,11 +19,10 @@ from ._submission_sql_repository import _SubmissionSQLRepository
 
 
 class _SubmissionManagerFactory(_ManagerFactory):
-
     __REPOSITORY_MAP = {"default": _SubmissionFSRepository, "sql": _SubmissionSQLRepository}
 
     @classmethod
-    def _build_manager(cls) -> Type[_SubmissionManager]:  # type: ignore
+    def _build_manager(cls) -> Type[_SubmissionManager]:
         if cls._using_enterprise():
             submission_manager = _load_fct(
                 cls._TAIPY_ENTERPRISE_CORE_MODULE + ".submission._submission_manager", "_SubmissionManager"

taipy/core/taipy.py

@@ -14,7 +14,7 @@ import pathlib
 import shutil
 import tempfile
 from datetime import datetime
-from typing import Any, Callable, Dict, List, Literal, Optional, Set, Union, overload
+from typing import Any, Callable, Dict, List, Literal, Optional, Set, Type, Union, overload
 
 from taipy.config import Scope
 from taipy.logger._taipy_logger import _TaipyLogger
@@ -1069,7 +1069,7 @@ def import_scenario(input_path: Union[str, pathlib.Path], override: bool = False
     if not zip_file_path.exists():
         raise FileNotFoundError(f"The import archive path '{zip_file_path}' does not exist.")
 
-    entity_managers: Dict[str, _Manager] = {
+    entity_managers: Dict[str, Type[_Manager]] = {
         "cycles": _CycleManagerFactory._build_manager(),
         "cycle": _CycleManagerFactory._build_manager(),
         "data_nodes": _DataManagerFactory._build_manager(),

taipy/core/task/_task_manager_factory.py

@@ -19,11 +19,10 @@ from ._task_sql_repository import _TaskSQLRepository
 
 
 class _TaskManagerFactory(_ManagerFactory):
-
     __REPOSITORY_MAP = {"default": _TaskFSRepository, "sql": _TaskSQLRepository}
 
     @classmethod
-    def _build_manager(cls) -> Type[_TaskManager]:  # type: ignore
+    def _build_manager(cls) -> Type[_TaskManager]:
         if cls._using_enterprise():
             task_manager = _load_fct(
                 cls._TAIPY_ENTERPRISE_CORE_MODULE + ".task._task_manager", "_TaskManager"