Fix #794: keep legacy database updated with lockfile

Author: tobiasraabe

docs/source/reference_guides/configuration.md

@@ -45,9 +45,9 @@ are welcome to also support macOS.
 ````{confval} database_url
 
 SQLite is the legacy state format. pytask now uses `pytask.lock` as the primary state
-backend and only consults the database when no lockfile exists. During that first run,
-the lockfile is written. Subsequent runs use only the lockfile and do not update the
-database state.
+backend for change detection. During migration, pytask consults the database when no
+lockfile exists and writes `pytask.lock`. For downgrade compatibility, pytask also keeps
+the legacy database state updated during builds.
 
 The `database_url` option remains for backwards compatibility and controls the legacy
 database location and dialect ([supported by sqlalchemy](https://docs.sqlalchemy.org/en/latest/core/engines.html#backend-specific-urls)).

docs/source/reference_guides/lockfile.md

@@ -5,8 +5,9 @@ git-friendly format so runs can be resumed or shared across machines.
 
 ```{note}
 SQLite is the legacy format. It is still read when no lockfile exists, and a lockfile
-is written during that first run. Subsequent runs use only the lockfile and do not
-update the database state.
+is written during that first run. The lockfile remains the primary backend for skip
+decisions, but pytask also keeps the legacy database updated for downgrade
+compatibility.
 ```
 
 ## Example

src/_pytask/database.py

@@ -7,7 +7,7 @@
 
 from sqlalchemy.engine import make_url
 
-from _pytask.database_utils import configure_database_if_present
+from _pytask.database_utils import create_database
 from _pytask.pluginmanager import hookimpl
 
 
@@ -45,8 +45,7 @@ def pytask_parse_config(config: dict[str, Any]) -> None:
 @hookimpl
 def pytask_post_parse(config: dict[str, Any]) -> None:
     """Post-parse the configuration."""
-    lockfile_path = config["root"] / "pytask.lock"
     command = config.get("command")
-    if lockfile_path.exists() and command in (None, "build"):
+    if command not in (None, "build"):
         return
-    configure_database_if_present(config["database_url"])
+    create_database(config["database_url"])

src/_pytask/state.py

@@ -91,5 +91,4 @@ def update_states(session: Session, task: PTask) -> None:
     lockfile_state = _get_lockfile_state(session)
     if lockfile_state is not None:
         lockfile_state.update_task(session, task)
-        return
     _db_update_states(session, task.signature)

src/_pytask/task_utils.py

@@ -186,7 +186,7 @@ def wrapper(func: T) -> TaskDecorated[T]:
 
     # When decorator is used without parentheses, call wrapper directly.
     if is_task_function(name) and kwargs is None:
-        return wrapper(cast("T", name))  # ty: ignore[invalid-argument-type]
+        return wrapper(cast("T", name))
     return wrapper
 
 

tests/test_database.py

@@ -58,14 +58,14 @@ def task_write(path=Path("in.txt"), produces=Path("out.txt")):
 
 
 def test_rename_database_w_config(tmp_path, runner):
-    """Database files are not created when using the lockfile backend."""
+    """Database files are created for compatibility with legacy backends."""
     path_to_db = tmp_path.joinpath(".db.sqlite")
     tmp_path.joinpath("pyproject.toml").write_text(
         "[tool.pytask.ini_options]\ndatabase_url='sqlite:///.db.sqlite'"
     )
     result = runner.invoke(cli, [tmp_path.as_posix()])
     assert result.exit_code == ExitCode.OK
-    assert not path_to_db.exists()
+    assert path_to_db.exists()
 
 
 def test_database_url_from_config_is_parsed(tmp_path):
@@ -80,11 +80,11 @@ def test_database_url_from_config_is_parsed(tmp_path):
 
 
 def test_rename_database_w_cli(tmp_path, runner):
-    """Database files are not created when using the lockfile backend."""
+    """Database files are created for compatibility with legacy backends."""
     path_to_db = tmp_path.joinpath(".db.sqlite")
     result = runner.invoke(
         cli,
         ["--database-url", "sqlite:///.db.sqlite", tmp_path.as_posix()],
     )
     assert result.exit_code == ExitCode.OK
-    assert not path_to_db.exists()
+    assert path_to_db.exists()

tests/test_lockfile.py

@@ -11,8 +11,10 @@
 from _pytask.lockfile import read_lockfile
 from _pytask.models import NodeInfo
 from _pytask.nodes import PythonNode
+from pytask import DatabaseSession
 from pytask import ExitCode
 from pytask import PathNode
+from pytask import State
 from pytask import TaskWithoutPath
 from pytask import build
 
@@ -81,7 +83,7 @@ def test_python_node_id_is_collision_free(tmp_path):
     assert left_id != right_id
 
 
-def test_lockfile_does_not_write_state_to_database(tmp_path):
+def test_lockfile_writes_state_to_database_for_compatibility(tmp_path):
     def func(path):
         path.write_text("data")
 
@@ -96,7 +98,13 @@ def func(path):
     assert (tmp_path / "pytask.lock").exists()
 
     db_path = tmp_path / ".pytask" / "pytask.sqlite3"
-    assert not db_path.exists()
+    assert db_path.exists()
+
+    task_signature = session.tasks[0].signature
+    with DatabaseSession() as db_session:
+        state = db_session.get(State, (task_signature, task_signature))
+    assert state is not None
+    assert state.hash_ == session.tasks[0].state()
 
 
 def test_clean_lockfile_removes_stale_entries(tmp_path):