fix: only create SQL engine when init the SQLRepository

Author: trgiangdo

.gitignore

@@ -82,7 +82,6 @@ dataset
 # Filesystem default local storage
 .data/
 .my_data/
-None
 
 # python notebook
 *.ipynb

src/taipy/core/_repository/_sql_repository.py

@@ -18,12 +18,11 @@
 from ..common.typing import Converter, Entity, ModelType
 from ..exceptions import ModelNotFound
 from ._abstract_repository import _AbstractRepository
-from .db._init_db import init_db
-from .db._sql_session import SessionLocal
+from .db._sql_session import _SQLSession
 
 
 class _SQLRepository(_AbstractRepository[ModelType, Entity]):
-    def __init__(self, model_type: Type[ModelType], converter: Type[Converter], session=SessionLocal()):
+    def __init__(self, model_type: Type[ModelType], converter: Type[Converter], session=None):
         """
         Holds common methods to be used and extended when the need for saving
         dataclasses in a SqlLite database.
@@ -36,10 +35,10 @@ def __init__(self, model_type: Type[ModelType], converter: Type[Converter], sess
             converter: A class that handles conversion to and from a database backend
             db: An SQLAlchemy session object
         """
+        SessionLocal = _SQLSession.init_db()
+        self.db = session or SessionLocal()
         self.model_type = model_type
-        self.db = session
         self.converter = converter
-        init_db()
 
     ###############################
     # ##   Inherited methods   ## #

src/taipy/core/_repository/db/__init__.py

@@ -8,4 +8,3 @@
 # Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
 # 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 ._init_db import engine

src/taipy/core/_repository/db/_init_db.py

@@ -12,6 +12,7 @@
 from functools import lru_cache
 
 from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy.pool import StaticPool
 
@@ -22,22 +23,48 @@
 from .._encoder import dumps
 
 
+class _SQLSession:
+    _engine = None
+    _SessionLocal = None
+
+    @classmethod
+    def init_db(cls):
+        if cls._SessionLocal:
+            return cls._SessionLocal
+
+        cls._engine = _build_engine()
+        cls._SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=cls._engine)
+
+        from ....core._version._version_model import _VersionModel
+        from ....core.cycle._cycle_model import _CycleModel
+        from ....core.data._data_model import _DataNodeModel
+        from ....core.job._job_model import _JobModel
+        from ....core.scenario._scenario_model import _ScenarioModel
+        from ....core.task._task_model import _TaskModel
+
+        _CycleModel.__table__.create(bind=cls._engine, checkfirst=True)
+        _DataNodeModel.__table__.create(bind=cls._engine, checkfirst=True)
+        _JobModel.__table__.create(bind=cls._engine, checkfirst=True)
+        _ScenarioModel.__table__.create(bind=cls._engine, checkfirst=True)
+        _TaskModel.__table__.create(bind=cls._engine, checkfirst=True)
+        _VersionModel.__table__.create(bind=cls._engine, checkfirst=True)
+
+        return cls._SessionLocal
+
+
 @lru_cache
-def _build_engine():
+def _build_engine() -> Engine:
     properties = Config.core.repository_properties
     try:
-        # More sql databases can be easily added in the future
-        engine = create_engine(
-            f"sqlite:///{properties.get('db_location')}?check_same_thread=False",
-            poolclass=StaticPool,
-            json_serializer=dumps,
-            json_deserializer=loads,
-        )
-        return engine
-
+        db_location = properties["db_location"]
     except KeyError:
         raise MissingRequiredProperty("Missing property db_location")
 
-
-engine = _build_engine()
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    # More sql databases can be easily added in the future
+    engine = create_engine(
+        f"sqlite:///{db_location}?check_same_thread=False",
+        poolclass=StaticPool,
+        json_serializer=dumps,
+        json_deserializer=loads,
+    )
+    return engine

src/taipy/core/_repository/db/_sql_session.py

@@ -21,7 +21,7 @@
 from sqlalchemy import create_engine, text
 
 from src.taipy.core._orchestrator._orchestrator_factory import _OrchestratorFactory
-from src.taipy.core._repository.db import engine
+from src.taipy.core._repository.db._sql_session import _build_engine
 from src.taipy.core._version._version import _Version
 from src.taipy.core._version._version_manager_factory import _VersionManagerFactory
 from src.taipy.core._version._version_model import _VersionModel
@@ -188,9 +188,6 @@ def default_multi_sheet_data_frame():
 
 @pytest.fixture(scope="session", autouse=True)
 def cleanup_files():
-    if os.path.exists("None"):
-        os.remove("None")
-
     yield
 
     if os.path.exists(".data"):
@@ -439,28 +436,29 @@ def sql_engine():
     return create_engine("sqlite:///:memory:")
 
 
-@pytest.fixture()
+@pytest.fixture
 def init_sql_repo(tmp_sqlite):
     Config.configure_core(repository_type="sql", repository_properties={"db_location": tmp_sqlite})
-    return tmp_sqlite
 
+    # Clean SQLite database
+    engine = _build_engine()
 
-@pytest.fixture(autouse=True)
-def clean_sql_db():
-    _CycleModel.__table__.drop(engine, checkfirst=True)
+    _CycleModel.__table__.drop(bind=engine, checkfirst=True)
     _DataNodeModel.__table__.drop(bind=engine, checkfirst=True)
     _JobModel.__table__.drop(bind=engine, checkfirst=True)
     _ScenarioModel.__table__.drop(bind=engine, checkfirst=True)
     _TaskModel.__table__.drop(bind=engine, checkfirst=True)
     _VersionModel.__table__.drop(bind=engine, checkfirst=True)
 
-    _CycleModel.__table__.create(engine, checkfirst=True)
+    _CycleModel.__table__.create(bind=engine, checkfirst=True)
     _DataNodeModel.__table__.create(bind=engine, checkfirst=True)
     _JobModel.__table__.create(bind=engine, checkfirst=True)
     _ScenarioModel.__table__.create(bind=engine, checkfirst=True)
     _TaskModel.__table__.create(bind=engine, checkfirst=True)
     _VersionModel.__table__.create(bind=engine, checkfirst=True)
 
+    return tmp_sqlite
+
 
 @pytest.fixture
 def entities_for_migration():

tests/conftest.py

@@ -21,27 +21,24 @@
 
 class TestCycleRepositories:
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_save_and_load(self, tmpdir, cycle, repo):
+    def test_save_and_load(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
         repository._save(cycle)
 
         obj = repository._load(cycle.id)
         assert isinstance(obj, Cycle)
 
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_exists(self, tmpdir, cycle, repo):
+    def test_exists(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
         repository._save(cycle)
 
         assert repository._exists(cycle.id)
         assert not repository._exists("not-existed-cycle")
 
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_load_all(self, tmpdir, cycle, repo):
+    def test_load_all(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
         for i in range(10):
             cycle.id = CycleId(f"cycle-{i}")
             repository._save(cycle)
@@ -50,9 +47,8 @@ def test_load_all(self, tmpdir, cycle, repo):
         assert len(data_nodes) == 10
 
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_load_all_with_filters(self, tmpdir, cycle, repo):
+    def test_load_all_with_filters(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
 
         for i in range(10):
             cycle.id = CycleId(f"cycle-{i}")
@@ -63,9 +59,8 @@ def test_load_all_with_filters(self, tmpdir, cycle, repo):
         assert len(objs) == 1
 
     @pytest.mark.parametrize("repo", [_CycleSQLRepository])
-    def test_delete(self, tmpdir, cycle, repo):
+    def test_delete(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
         repository._save(cycle)
 
         repository._delete(cycle.id)
@@ -74,9 +69,8 @@ def test_delete(self, tmpdir, cycle, repo):
             repository._load(cycle.id)
 
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_delete_all(self, tmpdir, cycle, repo):
+    def test_delete_all(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
 
         for i in range(10):
             cycle.id = CycleId(f"cycle-{i}")
@@ -89,9 +83,8 @@ def test_delete_all(self, tmpdir, cycle, repo):
         assert len(repository._load_all()) == 0
 
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_delete_many(self, tmpdir, cycle, repo):
+    def test_delete_many(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
 
         for i in range(10):
             cycle.id = CycleId(f"cycle-{i}")
@@ -105,9 +98,8 @@ def test_delete_many(self, tmpdir, cycle, repo):
         assert len(repository._load_all()) == 7
 
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_search(self, tmpdir, cycle, repo):
+    def test_search(self, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
 
         for i in range(10):
             cycle.id = CycleId(f"cycle-{i}")
@@ -121,9 +113,8 @@ def test_search(self, tmpdir, cycle, repo):
         assert isinstance(objs[0], Cycle)
 
     @pytest.mark.parametrize("repo", [_CycleFSRepository, _CycleSQLRepository])
-    def test_export(self, tmpdir, cycle, repo):
+    def test_export(self, tmpdir, cycle, repo, init_sql_repo):
         repository = repo()
-        repository.base_path = tmpdir
         repository._save(cycle)
 
         repository._export(cycle.id, tmpdir.strpath)