cook-build 0.6.2__tar.gz → 0.6.4__tar.gz

{cook_build-0.6.2/src/cook_build.egg-info → cook_build-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cook-build
-Version: 0.6.2
+Version: 0.6.4
 Summary: A task-centric build system with simple declarative recipes specified in Python
 Author: Till Hoffmann
 License: BSD-3-Clause

{cook_build-0.6.2 → cook_build-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cook-build"
-version = "0.6.2"
+version = "0.6.4"
 description = "A task-centric build system with simple declarative recipes specified in Python"
 readme = "README.md"
 license = {text = "BSD-3-Clause"}

{cook_build-0.6.2 → cook_build-0.6.4}/src/cook/__main__.py

@@ -122,6 +122,7 @@ class Command:
 
 class ExecArgs(Args):
     jobs: int
+    dry_run: bool
 
 
 class ExecCommand(Command):
@@ -135,11 +136,18 @@ class ExecCommand(Command):
         parser.add_argument(
             "--jobs", "-j", help="number of concurrent jobs", type=int, default=1
         )
+        parser.add_argument(
+            "--dry-run",
+            "-n",
+            help="show what \033[1mwould\033[0m be executed without running tasks",
+            action="store_true",
+            dest="dry_run",
+        )
         super().configure_parser(parser)
 
     def execute(self, controller: Controller, args: ExecArgs) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
         tasks = self.discover_tasks(controller, args)
-        controller.execute(tasks, num_concurrent=args.jobs)
+        controller.execute(tasks, num_concurrent=args.jobs, dry_run=args.dry_run)
 
 
 class LsArgs(Args):

{cook_build-0.6.2 → cook_build-0.6.4}/src/cook/contexts.py

@@ -33,7 +33,8 @@ Custom contexts can be implemented by inheriting from :class:`.Context` and impl
 from __future__ import annotations
 from pathlib import Path
 from types import ModuleType
-from typing import Callable, TYPE_CHECKING
+from typing import Callable, TYPE_CHECKING, TypeVar
+import warnings
 from . import actions
 from . import manager as manager_
 from . import task as task_
@@ -44,6 +45,8 @@ if TYPE_CHECKING:
     from .manager import Manager
     from .task import Task
 
+ContextT = TypeVar("ContextT", bound="Context")
+
 
 class Context:
     """
@@ -56,7 +59,7 @@ class Context:
     def __init__(self, manager: "Manager | None" = None) -> None:
         self.manager = manager or manager_.Manager.get_instance()
 
-    def __enter__(self) -> Context:
+    def __enter__(self: ContextT) -> ContextT:
         self.manager.contexts.append(self)
         return self
 
@@ -214,10 +217,21 @@ class normalize_dependencies(Context):
         task_dependencies = task.task_dependencies
         for dependency in task.dependencies:
             if isinstance(dependency, (task_.Task, create_group)):
-                task_dependencies.append(dependency)  # pyright: ignore[reportArgumentType]
+                warnings.warn(
+                    "Passing Task objects to 'dependencies' is deprecated. Use "
+                    "'task_dependencies' instead.",
+                    DeprecationWarning,
+                    stacklevel=4,
+                )
+                task_dependencies.append(dependency)
             else:
                 dependencies.append(dependency)
-        task.dependencies = [Path(x) for x in dependencies]  # pyright: ignore[reportAttributeAccessIssue]
+        # Convert all remaining dependencies (strings) to Path objects.
+        # After normalization, dependencies list contains only Path objects, but the
+        # Task.dependencies attribute is typed as list[PathOrStr | Task] to accept broader
+        # input before normalization. The isinstance checks in controller.py and manager.py
+        # validate this assumption at runtime.
+        task.dependencies = [Path(x) for x in dependencies]  # type: ignore[assignment]
 
         # Unpack group dependencies and look up tasks by name.
         task_dependencies = []

{cook_build-0.6.2 → cook_build-0.6.4}/src/cook/controller.py

@@ -109,6 +109,12 @@ class Controller:
         """
         dependencies = []
         for dependency in task.dependencies:
+            # Dependencies should be Path or str after normalize_dependencies runs.
+            # Tasks should have been moved to task_dependencies.
+            assert isinstance(dependency, (Path, str)), (
+                f"Unexpected dependency type '{type(dependency)}'. Dependencies "
+                "should be 'Path' or 'str' after 'normalize_dependencies'."
+            )
             dependency = Path(dependency).resolve()
             if not dependency.is_file():
                 LOGGER.debug("dependency %s of %s is missing", dependency, task)
@@ -227,7 +233,11 @@ class Controller:
         return False
 
     def execute(
-        self, tasks: "Task | list[Task]", num_concurrent: int = 1, interval: float = 1
+        self,
+        tasks: "Task | list[Task]",
+        num_concurrent: int = 1,
+        interval: float = 1,
+        dry_run: bool = False,
     ) -> None:
         """
         Execute one or more tasks.
@@ -235,6 +245,8 @@ class Controller:
         Args:
             tasks: Tasks to execute.
             num_concurrent: Number of concurrent threads to run.
+            interval: Interval for checking stop events.
+            dry_run: If True, show what would execute without running tasks.
         """
         if not isinstance(tasks, Sequence):
             tasks = [tasks]
@@ -250,7 +262,7 @@ class Controller:
             thread = threading.Thread(
                 target=self._target,
                 name=f"cook-thread-{i}",
-                args=(stop, input_queue, output_queue),
+                args=(stop, input_queue, output_queue, dry_run),
                 daemon=True,
             )
             thread.start()
@@ -282,30 +294,35 @@ class Controller:
                 # Unpack the results.
                 if event.kind == "fail":
                     # Update the status in the database.
-                    params = {
-                        "name": event.task.name,
-                        "last_failed": event.timestamp,
-                    }
-                    self.connection.execute(QUERIES["upsert_task_failed"], params)
-                    self.connection.commit()
+                    if not dry_run:
+                        params = {
+                            "name": event.task.name,
+                            "last_failed": event.timestamp,
+                        }
+                        self.connection.execute(QUERIES["upsert_task_failed"], params)
+                        self.connection.commit()
                     ex = event.exc_info[1]
                     raise util.FailedTaskError(ex, task=event.task) from ex
                 elif event.kind == "complete":
                     # Update the status in the database.
-                    params = {
-                        "name": event.task.name,
-                        "digest": event.digest,
-                        "last_completed": event.timestamp,
-                    }
-                    self.connection.execute(QUERIES["upsert_task_completed"], params)
-                    self.connection.commit()
+                    if not dry_run:
+                        params = {
+                            "name": event.task.name,
+                            "digest": event.digest,
+                            "last_completed": event.timestamp,
+                        }
+                        self.connection.execute(
+                            QUERIES["upsert_task_completed"], params
+                        )
+                        self.connection.commit()
                 elif event.kind == "start":
-                    params = {
-                        "name": event.task.name,
-                        "last_started": event.timestamp,
-                    }
-                    self.connection.execute(QUERIES["upsert_task_started"], params)
-                    self.connection.commit()
+                    if not dry_run:
+                        params = {
+                            "name": event.task.name,
+                            "last_started": event.timestamp,
+                        }
+                        self.connection.execute(QUERIES["upsert_task_started"], params)
+                        self.connection.commit()
                     continue
                 else:
                     raise ValueError(event)  # pragma: no cover
@@ -339,7 +356,11 @@ class Controller:
                     raise RuntimeError(f"thread {thread} failed to join")
 
     def _target(
-        self, stop: util.StopEvent, input_queue: Queue, output_queue: Queue
+        self,
+        stop: util.StopEvent,
+        input_queue: Queue,
+        output_queue: Queue,
+        dry_run: bool = False,
     ) -> None:
         LOGGER.debug(f"started thread `{threading.current_thread().name}`")
         while not stop.is_set():
@@ -359,12 +380,28 @@ class Controller:
 
             start = datetime.now()
             try:
-                # Execute the task.
-                LOGGER.log(
-                    logging.DEBUG if task.name.startswith("_") else logging.INFO,
-                    "executing %s ...",
-                    task,
-                )
+                # Execute or simulate the task.
+                if dry_run:
+                    LOGGER.log(
+                        logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                        "would execute %s",
+                        task,
+                    )
+                    if task.action:
+                        LOGGER.log(
+                            logging.DEBUG
+                            if task.name.startswith("_")
+                            else logging.INFO,
+                            "  action: %s",
+                            task.action,
+                        )
+                else:
+                    LOGGER.log(
+                        logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                        "executing %s ...",
+                        task,
+                    )
+
                 output_queue.put(
                     Event(
                         kind="start",
@@ -374,15 +411,17 @@ class Controller:
                         exc_info=(None, None, None),
                     )
                 )
-                task.execute(stop)
 
-                # Check that all targets were created.
-                for target in task.targets:
-                    if not target.is_file():
-                        raise FileNotFoundError(
-                            f"task {task} did not create target {target}"
-                        )
-                    LOGGER.debug("%s created `%s`", task, target)
+                if not dry_run:
+                    task.execute(stop)
+
+                    # Check that all targets were created.
+                    for target in task.targets:
+                        if not target.is_file():
+                            raise FileNotFoundError(
+                                f"task {task} did not create target {target}"
+                            )
+                        LOGGER.debug("%s created `%s`", task, target)
 
                 # Add the result to the output queue and report success.
                 output_queue.put(
@@ -394,13 +433,14 @@ class Controller:
                         exc_info=(None, None, None),
                     )
                 )
-                delta = util.format_timedelta(datetime.now() - start)
-                LOGGER.log(
-                    logging.DEBUG if task.name.startswith("_") else logging.INFO,
-                    "completed %s in %s",
-                    task,
-                    delta,
-                )
+                if not dry_run:
+                    delta = util.format_timedelta(datetime.now() - start)
+                    LOGGER.log(
+                        logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                        "completed %s in %s",
+                        task,
+                        delta,
+                    )
             except:  # noqa: E722
                 exc_info = sys.exc_info()
                 delta = util.format_timedelta(datetime.now() - start)

{cook_build-0.6.2 → cook_build-0.6.4}/src/cook/manager.py

@@ -96,8 +96,14 @@ class Manager:
                         f"tasks {task} and {other} both have target {path}"
                     )
                 task_by_target[path] = task
-            for path in task.dependencies:
-                path = Path(path).resolve()
+            for dependency in task.dependencies:
+                # Dependencies should be Path or str after normalize_dependencies runs.
+                # Tasks should have been moved to task_dependencies.
+                assert isinstance(dependency, (Path, str)), (
+                    f"Unexpected dependency type '{type(dependency)}'. Dependencies "
+                    "should be 'Path' or 'str' after 'normalize_dependencies'."
+                )
+                path = Path(dependency).resolve()
                 tasks_by_file_dependency.setdefault(path, set()).add(task)
 
         # Build a directed graph of dependencies based on files produced and consumed by tasks.
@@ -132,8 +138,8 @@ def create_task(
     name: str,
     *,
     action: "Action | str | None" = None,
-    targets: list["Path"] | None = None,
-    dependencies: list["Path"] | None = None,
+    targets: list["Path | str"] | None = None,
+    dependencies: list["Path | str | Task"] | None = None,
     task_dependencies: list["Task"] | None = None,
     location: tuple[str, int] | None = None,
 ) -> "Task":

{cook_build-0.6.2 → cook_build-0.6.4}/src/cook/task.py

@@ -19,7 +19,7 @@ class Task:
         self,
         name: str,
         *,
-        dependencies: list["PathOrStr"] | None = None,
+        dependencies: list["PathOrStr | Task"] | None = None,
         targets: list["PathOrStr"] | None = None,
         action: Action | None = None,
         task_dependencies: list[Task] | None = None,

{cook_build-0.6.2 → cook_build-0.6.4/src/cook_build.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cook-build
-Version: 0.6.2
+Version: 0.6.4
 Summary: A task-centric build system with simple declarative recipes specified in Python
 Author: Till Hoffmann
 License: BSD-3-Clause

{cook_build-0.6.2 → cook_build-0.6.4}/tests/test_actions.py

@@ -11,7 +11,7 @@ from unittest import mock
 
 def test_shell_action(tmp_wd: Path) -> None:
     action = SubprocessAction("echo hello > world.txt", shell=True)
-    action.execute(None)
+    action.execute(None)  # type: ignore[arg-type]
     assert (tmp_wd / "world.txt").read_text().strip() == "hello"
 
 
@@ -27,7 +27,7 @@ def test_shell_action_timeout() -> None:
 
     action = SubprocessAction(["sleep", "2"])
     with Timer() as timer, pytest.raises(SubprocessError, match="SIGTERM"):
-        action.execute(None, stop)
+        action.execute(None, stop)  # type: ignore[arg-type]
 
     assert 1 < timer.duration < 2
     assert not thread.is_alive()
@@ -35,14 +35,14 @@ def test_shell_action_timeout() -> None:
 
 def test_subprocess_action(tmp_wd: Path) -> None:
     action = SubprocessAction(["touch", "foo"])
-    action.execute(None)
+    action.execute(None)  # type: ignore[arg-type]
     assert (tmp_wd / "foo").is_file()
 
 
 def test_bad_subprocess_action() -> None:
     action = SubprocessAction("false")
     with pytest.raises(SubprocessError):
-        action.execute(None)
+        action.execute(None)  # type: ignore[arg-type]
 
 
 def test_subprocess_action_repr() -> None:
@@ -54,7 +54,7 @@ def test_function_action() -> None:
     args = []
 
     action = FunctionAction(args.append)
-    action.execute(42)
+    action.execute(42)  # type: ignore[arg-type]
 
     assert args == [42]
 
@@ -63,13 +63,13 @@ def test_composite_action() -> None:
     args = []
 
     action = CompositeAction(FunctionAction(args.append), FunctionAction(args.append))
-    action.execute("hello")
+    action.execute("hello")  # type: ignore[arg-type]
     assert args == ["hello", "hello"]
 
 
 def test_module_action() -> None:
     action = ModuleAction([pytest, "-h"])
-    action.execute(None)
+    action.execute(None)  # type: ignore[arg-type]
 
     with pytest.raises(ValueError, match="shell execution"):
         ModuleAction([pytest], shell=True)
@@ -84,12 +84,12 @@ def test_module_action() -> None:
 def test_module_action_debug() -> None:
     with mock.patch("subprocess.Popen") as Popen:
         Popen().wait = mock.MagicMock(return_value=0)
-        ModuleAction([pytest], debug=True).execute(None)
+        ModuleAction([pytest], debug=True).execute(None)  # type: ignore[arg-type]
     Popen.assert_called_with([sys.executable, "-m", "pdb", "-m", "pytest"])
 
     with mock.patch("subprocess.Popen") as Popen:
         Popen().wait = mock.MagicMock(return_value=0)
-        ModuleAction([pytest], debug=False).execute(None)
+        ModuleAction([pytest], debug=False).execute(None)  # type: ignore[arg-type]
     Popen.assert_called_with([sys.executable, "-m", "pytest"])
 
 
@@ -100,5 +100,5 @@ def test_composite_digest() -> None:
     ]
     assert CompositeAction(*actions).hexdigest
 
-    actions.append(FunctionAction(print))
+    actions.append(FunctionAction(print))  # type: ignore[arg-type]
     assert CompositeAction(*actions).hexdigest is None

{cook_build-0.6.2 → cook_build-0.6.4}/tests/test_contexts.py

@@ -33,7 +33,7 @@ def test_function_context(m: Manager) -> None:
 def test_missing_task_context(m: Manager) -> None:
     with (
         pytest.raises(ValueError, match="did not return a task"),
-        FunctionContext(lambda _: None),
+        FunctionContext(lambda _: None),  # type: ignore[arg-type]
     ):
         m.create_task("my-task")
 
@@ -42,7 +42,7 @@ def test_context_management(m: Manager) -> None:
     with pytest.raises(RuntimeError, match="no active contexts"), Context():
         m.contexts = []
     with pytest.raises(RuntimeError, match="unexpected context"), Context():
-        m.contexts.append("something else")
+        m.contexts.append("something else")  # type: ignore[arg-type]
 
 
 def test_create_target_directories(
@@ -59,17 +59,20 @@ def test_create_target_directories(
 
 
 def test_create_target_directories_with_multiple_targets(
-    m: Manager, tmp_wd: Path, conn: sqlite3
+    m: Manager, tmp_wd: Path, conn: sqlite3.Connection
 ) -> None:
     filenames = [
         tmp_wd / "this/is/a/hierarchy.txt",
         tmp_wd / "this/is/a/hierarchy2.txt",
     ]
+    filename: Path | None = None
+    task: Task | None = None
     with normalize_action(), create_target_directories():
         for filename in filenames:
             task = m.create_task(
                 filename.name, targets=[filename], action=["touch", filename]
             )
+    assert filename is not None and task is not None
     assert not filename.parent.is_dir()
 
     controller = Controller(m.resolve_dependencies(), conn)
@@ -131,11 +134,27 @@ def test_normalize_dependencies(m: Manager) -> None:
     with create_group("g") as g:
         base = m.create_task("base")
     with normalize_dependencies():
-        task = m.create_task("task1", dependencies=[g])
+        task = m.create_task("task3", task_dependencies=["g"])
         assert task.task_dependencies == [g.task]
 
-        task = m.create_task("task2", dependencies=[base])
-        assert task.task_dependencies == [base]
 
-        task = m.create_task("task3", task_dependencies=["g"])
+def test_normalize_dependencies_deprecated_syntax(m: Manager) -> None:
+    """Test that passing Tasks to dependencies parameter emits DeprecationWarning."""
+    with create_group("g") as g:
+        base = m.create_task("base")
+    with normalize_dependencies():
+        # Test with group
+        with pytest.warns(
+            DeprecationWarning,
+            match="Passing Task objects to 'dependencies' is deprecated",
+        ):
+            task = m.create_task("task1", dependencies=[g])
         assert task.task_dependencies == [g.task]
+
+        # Test with regular task
+        with pytest.warns(
+            DeprecationWarning,
+            match="Passing Task objects to 'dependencies' is deprecated",
+        ):
+            task = m.create_task("task2", dependencies=[base])
+        assert task.task_dependencies == [base]

{cook_build-0.6.2 → cook_build-0.6.4}/tests/test_controller.py

@@ -188,7 +188,7 @@ def test_digest_cache(m: Manager, conn: Connection, tmp_wd: Path) -> None:
 
 
 def test_skip_if_no_stale_tasks(m: Manager, conn: Connection, tmp_wd: Path) -> None:
-    c = Controller(m, conn)
+    c = Controller(m.resolve_dependencies(), conn)
     c.execute([])
 
 

{cook_build-0.6.2 → cook_build-0.6.4}/tests/test_main.py

@@ -1,3 +1,4 @@
+import colorama
 from cook.__main__ import __main__, Formatter
 import logging
 from pathlib import Path
@@ -9,6 +10,13 @@ import sys
 RECIPES = Path(__file__).parent / "recipes"
 
 
+def strip_colors(text: str) -> str:
+    for ansi_codes in [colorama.Fore, colorama.Back]:
+        for code in vars(ansi_codes).values():
+            text = text.replace(code, "")
+    return text
+
+
 def test_blah_recipe_run(tmp_wd: Path) -> None:
     __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "run"])
 
@@ -28,35 +36,35 @@ def test_blah_recipe_ls(
     __main__(["--recipe", str(RECIPES / "blah.py"), "ls", *patterns])
     out, _ = capsys.readouterr()
     for task in expected:
-        assert f"<task `{task}` @ " in pytest.shared.strip_colors(out)
+        assert f"<task `{task}` @ " in strip_colors(out)
 
 
 def test_blah_recipe_info(tmp_wd: Path, capsys: pytest.CaptureFixture) -> None:
     __main__(["--recipe", str(RECIPES / "blah.py"), "info", "link"])
     stdout, _ = capsys.readouterr()
-    assert "status: stale" in pytest.shared.strip_colors(stdout)
+    assert "status: stale" in strip_colors(stdout)
 
     __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "link"])
     __main__(["--recipe", str(RECIPES / "blah.py"), "info", "link"])
     stdout, _ = capsys.readouterr()
-    assert "status: current" in pytest.shared.strip_colors(stdout)
+    assert "status: current" in strip_colors(stdout)
 
     __main__(["--recipe", str(RECIPES / "blah.py"), "info", "run"])
     stdout, _ = capsys.readouterr()
-    assert "targets: -" in pytest.shared.strip_colors(stdout)
+    assert "targets: -" in strip_colors(stdout)
 
     # Check filtering based on stale/current status.
     __main__(["--recipe", str(RECIPES / "blah.py"), "info", "--stale"])
     stdout, _ = capsys.readouterr()
-    assert "status: current" not in pytest.shared.strip_colors(stdout)
+    assert "status: current" not in strip_colors(stdout)
 
     __main__(["--recipe", str(RECIPES / "blah.py"), "info", "--current"])
     stdout, _ = capsys.readouterr()
-    assert "status: stale" not in pytest.shared.strip_colors(stdout)
+    assert "status: stale" not in strip_colors(stdout)
 
     __main__(["--recipe", str(RECIPES / "blah.py"), "info"])
     stdout, _ = capsys.readouterr()
-    stdout = pytest.shared.strip_colors(stdout)
+    stdout = strip_colors(stdout)
     assert "status: stale" in stdout and "status: current" in stdout
 
     # Check only one can be given.
@@ -119,3 +127,66 @@ def test_terrible_recipe(caplog: pytest.LogCaptureFixture) -> None:
     with pytest.raises(SystemExit), caplog.at_level("CRITICAL"):
         __main__(["--recipe", str(RECIPES / "terrible.not-py"), "ls"])
     assert "failed to load recipe" in caplog.text
+
+
+def test_dry_run_shows_tasks(tmp_wd: Path, caplog: pytest.LogCaptureFixture) -> None:
+    """Dry-run should show what would execute without running tasks."""
+    with caplog.at_level(logging.INFO):
+        __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "run"])
+
+    # Should show "would execute" messages
+    assert "would execute <task `create_source`" in caplog.text
+    assert "would execute <task `compile`" in caplog.text
+    assert "would execute <task `link`" in caplog.text
+    assert "would execute <task `run`" in caplog.text
+
+    # Should show actions
+    assert "action:" in caplog.text
+
+    # Should NOT show "executing" or "completed" messages
+    assert "executing <task" not in caplog.text
+    assert "completed <task" not in caplog.text
+
+
+def test_dry_run_does_not_create_files(tmp_wd: Path) -> None:
+    """Dry-run should not create target files."""
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "link"])
+
+    # Files should NOT be created
+    assert not (tmp_wd / "blah.c").exists()
+    assert not (tmp_wd / "blah.o").exists()
+    assert not (tmp_wd / "blah").exists()
+
+
+def test_dry_run_does_not_update_database(tmp_wd: Path) -> None:
+    """Dry-run should not update the database."""
+    # First, run normally to create database entry
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "link"])
+
+    # Check the database was updated
+    __main__(["--recipe", str(RECIPES / "blah.py"), "info", "link"])
+
+    # Reset the task
+    __main__(["--recipe", str(RECIPES / "blah.py"), "reset", "link"])
+
+    # Now dry-run should not update last_completed
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "link"])
+
+    # Task should still be stale (database not updated)
+    __main__(["--recipe", str(RECIPES / "blah.py"), "info", "--stale", "link"])
+
+
+def test_dry_run_with_no_stale_tasks(
+    tmp_wd: Path, caplog: pytest.LogCaptureFixture
+) -> None:
+    """Dry-run with no stale tasks should be silent."""
+    # First, run normally
+    __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "link"])
+
+    # Now dry-run with nothing stale
+    caplog.clear()
+    with caplog.at_level(logging.INFO):
+        __main__(["--recipe", str(RECIPES / "blah.py"), "exec", "--dry-run", "link"])
+
+    # Should be silent (no "would execute" messages)
+    assert "would execute" not in caplog.text

{cook_build-0.6.2 → cook_build-0.6.4}/tests/test_manager.py

@@ -85,7 +85,7 @@ def test_get_manager_instance() -> None:
     with Manager() as m:
         assert Manager.get_instance() is m
     with pytest.raises(RuntimeError, match="unexpected manager"), Manager():
-        Manager._INSTANCE = "asdf"
+        Manager._INSTANCE = "asdf"  # pyright: ignore[reportAttributeAccessIssue]
     with pytest.raises(ValueError, match="already active"), Manager(), Manager():
         pass