cook-build 0.6.4__py3-none-any.whl → 0.7.0__py3-none-any.whl

cook/__init__.py

@@ -1,8 +1,7 @@
 from .controller import Controller
-from .manager import create_task, Manager
+from .manager import Manager, create_task
 from .task import Task
 
-
 __all__ = [
     "Controller",
     "create_task",

cook/__main__.py

@@ -1,29 +1,30 @@
 import argparse
-import colorama
-from contextlib import closing
-from datetime import datetime
+import asyncio
 import fnmatch
 import importlib.util
 import logging
 import os
-from pathlib import Path
 import re
 import sqlite3
 import sys
 import textwrap
+from contextlib import closing
+from datetime import datetime
+from pathlib import Path
 from typing import Iterable
 
+import colorama
+
 from .contexts import (
     create_target_directories,
     normalize_action,
     normalize_dependencies,
 )
-from .controller import Controller, QUERIES
+from .controller import QUERIES, Controller
 from .manager import Manager
 from .task import Task
 from .util import FailedTaskError, format_datetime, format_timedelta
 
-
 LOGGER = logging.getLogger("cook")
 
 
@@ -147,7 +148,9 @@ class ExecCommand(Command):
 
     def execute(self, controller: Controller, args: ExecArgs) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
         tasks = self.discover_tasks(controller, args)
-        controller.execute(tasks, num_concurrent=args.jobs, dry_run=args.dry_run)
+        asyncio.run(
+            controller.execute(tasks, num_concurrent=args.jobs, dry_run=args.dry_run)
+        )
 
 
 class LsArgs(Args):

cook/actions.py

@@ -8,51 +8,58 @@ multiple actions using :class:`.CompositeAction`, and executing modules as scrip
 :class:`.ModuleAction`.
 
 Custom actions can be implemented by inheriting from :class:`.Action` and implementing the
-:meth:`~.Action.execute` method which receives a :class:`~.task.Task`. The method should execute the
-action; its return value is ignored. For example, the following action waits for a specified time.
+:meth:`~.Action.execute` method which receives a :class:`~.task.Task`. The method should be async
+and its return value is ignored. For example, the following action waits for a specified time.
 
 .. doctest::
 
     >>> from cook.actions import Action
     >>> from cook.task import Task
-    >>> from time import sleep, time
+    >>> import asyncio
+    >>> from time import time
 
     >>> class SleepAction(Action):
     ...     def __init__(self, delay: float) -> None:
     ...         self.delay = delay
     ...
-    ...     def execute(self, task: Task) -> None:
+    ...     async def execute(self, task: Task) -> None:
     ...         start = time()
-    ...         sleep(self.delay)
+    ...         await asyncio.sleep(self.delay)
     ...         print(f"time: {time() - start:.3f}")
 
     >>> action = SleepAction(0.1)
-    >>> action.execute(None)
+    >>> asyncio.run(action.execute(None))
     time: 0.1...
+
+For backwards compatibility, synchronous execute methods are also supported but will run in an
+executor with a deprecation warning.
 """
 
+import asyncio
 import hashlib
+import logging
 import os
 import shlex
 import subprocess
 import sys
 from types import ModuleType
-from typing import Callable, TYPE_CHECKING
-
+from typing import TYPE_CHECKING, Callable
 
 if TYPE_CHECKING:
     from .task import Task
-    from .util import StopEvent
+
+
+LOGGER = logging.getLogger(__name__)
 
 
 class Action:
     """
-    Action to perform when a task is executed in its own thread.
+    Action to perform when a task is executed.
     """
 
-    def execute(self, task: "Task", stop: "StopEvent | None" = None) -> None:
+    async def execute(self, task: "Task") -> None:
         """
-        Execute the action.
+        Execute the action asynchronously.
         """
         raise NotImplementedError
 
@@ -80,17 +87,23 @@ class FunctionAction(Action):
         self.args = args
         self.kwargs = kwargs
 
-    def execute(self, task: "Task", stop: "StopEvent | None" = None) -> None:
-        self.func(task, *self.args, **self.kwargs)
+    async def execute(self, task: "Task") -> None:
+        # Check if the function is already async
+        if asyncio.iscoroutinefunction(self.func):
+            await self.func(task, *self.args, **self.kwargs)
+        else:
+            # Run sync function in executor
+            loop = asyncio.get_running_loop()
+            await loop.run_in_executor(None, self.func, task, *self.args, **self.kwargs)
 
 
 class SubprocessAction(Action):
     """
-    Run a subprocess.
+    Run a subprocess asynchronously.
 
     Args:
-        *args: Positional arguments for :class:`subprocess.Popen`.
-        **kwargs: Keyword arguments for :class:`subprocess.Popen`.
+        *args: Positional arguments for subprocess execution.
+        **kwargs: Keyword arguments for subprocess execution.
 
     Example:
 
@@ -98,47 +111,55 @@ class SubprocessAction(Action):
 
             >>> from cook.actions import SubprocessAction
             >>> from pathlib import Path
+            >>> import asyncio
 
             >>> action = SubprocessAction(["touch", "hello.txt"])
-            >>> action.execute(None)
+            >>> asyncio.run(action.execute(None))
             >>> Path("hello.txt").is_file()
             True
     """
 
     def __init__(self, *args, **kwargs) -> None:
+        # Validate shell argument early
+        if kwargs.get("shell", False) and args and not isinstance(args[0], str):
+            raise ValueError("shell=True requires string args")
         self.args = args
         self.kwargs = kwargs
 
-    def execute(self, task: "Task", stop: "StopEvent | None" = None) -> None:
-        # Repeatedly wait for the process to complete, checking the stop event after each poll.
-        interval = stop.interval if stop else None
-        process = subprocess.Popen(*self.args, **self.kwargs)
-        while True:
-            try:
-                returncode = process.wait(interval)
-                if returncode:
-                    raise subprocess.CalledProcessError(returncode, process.args)
-                return
-            except subprocess.TimeoutExpired:
-                if stop and stop.is_set():
-                    break
-
-        # Clean up the process by trying to terminate it and then killing it.
-        for method in [process.terminate, process.kill]:
-            method()
-            try:
-                returncode = process.wait(max(interval, 3) if interval else None)
-                if returncode:
-                    raise subprocess.CalledProcessError(returncode, process.args)
-                # The process managed to exit gracefully after the main loop. This is unlikely.
-                return  # pragma: no cover
-            except subprocess.TimeoutExpired:  # pragma: no cover
-                pass
-
-        # We couldn't kill the process. Also very unlikely.
-        raise subprocess.SubprocessError(
-            f"failed to shut down {process}"
-        )  # pragma: no cover
+    async def execute(self, task: "Task") -> None:
+        # Get the command arguments
+        (args,) = self.args
+        shell = self.kwargs.get("shell", False)
+        other_kwargs = {k: v for k, v in self.kwargs.items() if k != "shell"}
+
+        # Create the subprocess
+        if shell:
+            process = await asyncio.create_subprocess_shell(args, **other_kwargs)
+        else:
+            # Exec mode: args can be a string (single command) or list
+            if isinstance(args, str):
+                # Single command string - treat as program name with no arguments
+                process = await asyncio.create_subprocess_exec(args, **other_kwargs)
+            else:
+                # List of arguments
+                process = await asyncio.create_subprocess_exec(*args, **other_kwargs)
+
+        try:
+            # Wait for the process to complete
+            returncode = await process.wait()
+            if returncode:
+                raise subprocess.CalledProcessError(returncode, args)
+
+        except asyncio.CancelledError:
+            # Task was cancelled - terminate the subprocess
+            if process.returncode is None:
+                process.terminate()
+                try:
+                    await asyncio.wait_for(process.wait(), timeout=3)
+                except asyncio.TimeoutError:
+                    process.kill()
+                    await process.wait()
+            raise
 
     @property
     def hexdigest(self) -> str:
@@ -169,9 +190,9 @@ class CompositeAction(Action):
     def __init__(self, *actions: Action) -> None:
         self.actions = actions
 
-    def execute(self, task: "Task", stop: "StopEvent | None" = None) -> None:
+    async def execute(self, task: "Task") -> None:
         for action in self.actions:
-            action.execute(task, stop)
+            await action.execute(task)
 
     @property
     def hexdigest(self) -> str | None:

cook/contexts.py

@@ -31,15 +31,15 @@ Custom contexts can be implemented by inheriting from :class:`.Context` and impl
 """
 
 from __future__ import annotations
+
+import warnings
 from pathlib import Path
 from types import ModuleType
-from typing import Callable, TYPE_CHECKING, TypeVar
-import warnings
-from . import actions
+from typing import TYPE_CHECKING, Callable, TypeVar
+
+from . import actions, util
 from . import manager as manager_
 from . import task as task_
-from . import util
-
 
 if TYPE_CHECKING:
     from .manager import Manager

cook/controller.py

@@ -1,22 +1,19 @@
-from dataclasses import dataclass
-from datetime import datetime
+import asyncio
 import hashlib
 import logging
-import networkx as nx
+import warnings
+from datetime import datetime
 from pathlib import Path
-from queue import Empty, Queue
 from sqlite3 import Connection
-import sys
-import threading
-from types import TracebackType
 from typing import (
-    cast,
-    Iterable,
-    Literal,
-    Sequence,
     TYPE_CHECKING,
+    Sequence,
+    cast,
     overload,
 )
+
+import networkx as nx
+
 from . import util
 
 if TYPE_CHECKING:
@@ -75,18 +72,6 @@ QUERIES = {
 }
 
 
-@dataclass
-class Event:
-    kind: Literal["start", "complete", "fail"]
-    task: "Task"
-    timestamp: datetime
-    exc_info: (
-        tuple[type[BaseException], BaseException, TracebackType]
-        | tuple[None, None, None]
-    )
-    digest: str | None
-
-
 class Controller:
     """
     Controller to manage dependencies and execute tasks.
@@ -232,42 +217,33 @@ class Controller:
         LOGGER.debug("%s is up to date", task)
         return False
 
-    def execute(
+    async def execute(
         self,
         tasks: "Task | list[Task]",
         num_concurrent: int = 1,
-        interval: float = 1,
+        interval: float | None = None,
         dry_run: bool = False,
     ) -> None:
         """
-        Execute one or more tasks.
+        Execute one or more tasks asynchronously.
 
         Args:
             tasks: Tasks to execute.
-            num_concurrent: Number of concurrent threads to run.
-            interval: Interval for checking stop events.
+            num_concurrent: Number of concurrent tasks to run.
+            interval: Deprecated, kept for backward compatibility.
             dry_run: If True, show what would execute without running tasks.
         """
+        if interval is not None:  # pragma: no cover
+            warnings.warn(
+                "The 'interval' parameter is deprecated and has no effect",
+                DeprecationWarning,
+                stacklevel=2,
+            )
         if not isinstance(tasks, Sequence):
             tasks = [tasks]
         if not any(self.is_stale(tasks)):
             return
 
-        # Start the worker threads.
-        threads: list[threading.Thread] = []
-        input_queue = Queue()
-        output_queue = Queue[Event]()
-        stop = util.StopEvent(interval)
-        for i in range(num_concurrent):
-            thread = threading.Thread(
-                target=self._target,
-                name=f"cook-thread-{i}",
-                args=(stop, input_queue, output_queue, dry_run),
-                daemon=True,
-            )
-            thread.start()
-            threads.append(thread)
-
         # Get the subgraph of stale nodes.
         stale_nodes = [
             node
@@ -276,191 +252,119 @@ class Controller:
         ]
         dependencies = cast(nx.DiGraph, self.dependencies.subgraph(stale_nodes).copy())
 
-        # Initialize the input queue with leaf nodes.
-        for node, out_degree in cast(Iterable, dependencies.out_degree()):
-            if out_degree == 0:
-                input_queue.put((node, self._evaluate_task_hexdigest(node)))
+        # Create semaphore for concurrency control
+        semaphore = asyncio.Semaphore(num_concurrent)
 
-        try:
-            while dependencies.number_of_nodes():
-                # Try to get the next item in the queue, continuing if there's nothing available.
-                try:
-                    event = output_queue.get(timeout=interval)
-                except Empty:  # pragma: no cover
-                    continue
-
-                assert event is not None, "output queue returned `None`; this is a bug"
-
-                # Unpack the results.
-                if event.kind == "fail":
-                    # Update the status in the database.
-                    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.
-                    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":
-                    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
-
-                # Check if the stop event is set and abort if so.
-                if stop.is_set():
-                    break
-
-                # Add tasks that are now leaf nodes to the tree.
-                predecessors = list(dependencies.predecessors(event.task))
-                dependencies.remove_node(event.task)
-                self.dependencies.add_node(event.task, is_stale=False)
-                for node, out_degree in cast(
-                    Iterable, dependencies.out_degree(predecessors)
-                ):
-                    if out_degree == 0:
-                        input_queue.put((node, self._evaluate_task_hexdigest(node)))
-        finally:
-            # Set the stop event and add "None" to the queue so the workers stop waiting.
-            LOGGER.debug(
-                "set stop event for threads: %s", [thread.name for thread in threads]
+        # Create futures for all stale tasks
+        task_futures: dict["Task", asyncio.Task] = {}
+        for task in dependencies:
+            task_futures[task] = asyncio.create_task(
+                self._execute_task(task, task_futures, dependencies, semaphore, dry_run)
             )
-            stop.set()
-            for thread in threads:
-                input_queue.put((None, None))
 
-            # Shut down the worker threads.
-            for thread in threads:
-                thread.join(3 * stop.interval)
-                if thread.is_alive():  # pragma: no cover
-                    raise RuntimeError(f"thread {thread} failed to join")
-
-    def _target(
+        # Wait for requested tasks
+        requested_futures = [task_futures[t] for t in tasks if t in task_futures]
+        try:
+            await asyncio.gather(*requested_futures)
+        except Exception:
+            # Cancel all pending tasks
+            for future in task_futures.values():
+                if not future.done():
+                    future.cancel()
+            # Wait for all cancellations to complete
+            await asyncio.gather(*task_futures.values(), return_exceptions=True)
+            raise
+
+    async def _execute_task(
         self,
-        stop: util.StopEvent,
-        input_queue: Queue,
-        output_queue: Queue,
-        dry_run: bool = False,
+        task: "Task",
+        task_futures: dict["Task", asyncio.Task],
+        dependencies: nx.DiGraph,
+        semaphore: asyncio.Semaphore,
+        dry_run: bool,
     ) -> None:
-        LOGGER.debug(f"started thread `{threading.current_thread().name}`")
-        while not stop.is_set():
-            try:
-                task: "Task"
-                digest: str
-                task, digest = input_queue.get(timeout=stop.interval)
-            except Empty:  # pragma: no cover
-                # It's unlikely there's nothing on the queue, but let's handle it anyway.
-                continue
-            # Check the stop event before executing the task; it may have been set while we were
-            # waiting for the next task in the queue.
-            if stop.is_set():
-                break
-
-            assert task is not None, "input queue returned `None`; this is a bug"
-
-            start = datetime.now()
-            try:
-                # 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,
-                    )
+        """Execute a single task after waiting for its dependencies."""
+        # Wait for all dependencies to complete
+        dep_tasks = list(dependencies.successors(task))
+        if dep_tasks:
+            dep_futures = [task_futures[dep] for dep in dep_tasks]
+            await asyncio.gather(*dep_futures)
 
-                output_queue.put(
-                    Event(
-                        kind="start",
-                        task=task,
-                        digest=None,
-                        timestamp=start,
-                        exc_info=(None, None, None),
-                    )
-                )
+        start = datetime.now()
+        digest = self._evaluate_task_hexdigest(task)
 
-                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(
-                    Event(
-                        kind="complete",
-                        task=task,
-                        digest=digest,
-                        timestamp=datetime.now(),
-                        exc_info=(None, None, None),
-                    )
+        try:
+            # Log what we're doing
+            if dry_run:
+                LOGGER.log(
+                    logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                    "would execute %s",
+                    task,
                 )
-                if not dry_run:
-                    delta = util.format_timedelta(datetime.now() - start)
+                if task.action:
                     LOGGER.log(
                         logging.DEBUG if task.name.startswith("_") else logging.INFO,
-                        "completed %s in %s",
-                        task,
-                        delta,
+                        "  action: %s",
+                        task.action,
                     )
-            except:  # noqa: E722
-                exc_info = sys.exc_info()
-                delta = util.format_timedelta(datetime.now() - start)
-                LOGGER.exception(
-                    "failed to execute %s after %s", task, delta, exc_info=exc_info
+            else:
+                LOGGER.log(
+                    logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                    "executing %s ...",
+                    task,
                 )
-                stop.set()
-                output_queue.put(
-                    Event(
-                        kind="fail",
-                        task=task,
-                        digest=digest,
-                        timestamp=datetime.now(),
-                        exc_info=sys.exc_info(),
-                    )
+
+            # Update DB for start
+            if not dry_run:
+                params = {"name": task.name, "last_started": start}
+                self.connection.execute(QUERIES["upsert_task_started"], params)
+                self.connection.commit()
+
+            # Execute the task
+            if not dry_run:
+                async with semaphore:
+                    await task.execute()
+
+                # 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)
+
+            # Update DB for completion
+            if not dry_run:
+                params = {
+                    "name": task.name,
+                    "digest": digest,
+                    "last_completed": datetime.now(),
+                }
+                self.connection.execute(QUERIES["upsert_task_completed"], params)
+                self.connection.commit()
+
+                # Log completion
+                delta = util.format_timedelta(datetime.now() - start)
+                LOGGER.log(
+                    logging.DEBUG if task.name.startswith("_") else logging.INFO,
+                    "completed %s in %s",
+                    task,
+                    delta,
                 )
 
-        # Put anything on the queue in case the parent is waiting.
-        LOGGER.debug(f"exiting thread `{threading.current_thread().name}`")
-        output_queue.put(None)
+            # Mark task as no longer stale
+            self.dependencies.nodes[task]["is_stale"] = False
+
+        except Exception as ex:
+            # Update DB for failure
+            if not dry_run:
+                params = {"name": task.name, "last_failed": datetime.now()}
+                self.connection.execute(QUERIES["upsert_task_failed"], params)
+                self.connection.commit()
+
+            delta = util.format_timedelta(datetime.now() - start)
+            LOGGER.exception("failed to execute %s after %s", task, delta)
+            raise util.FailedTaskError(ex, task=task) from ex
 
     def reset(self, *tasks: "Task") -> None:
         # TODO: add tests for resetting.

cook/manager.py

@@ -1,12 +1,14 @@
 from __future__ import annotations
+
 import logging
-import networkx as nx
 from pathlib import Path
 from typing import TYPE_CHECKING
+
+import networkx as nx
+
 from . import task as task_
 from . import util
 
-
 if TYPE_CHECKING:
     from .actions import Action
     from .contexts import Context
@@ -47,21 +49,21 @@ class Manager:
             raise ValueError("no manager is active")
         return Manager._INSTANCE
 
-    def create_task(self, name: str, **kwargs):
+    def create_task(self, name: str | None = None, **kwargs):
         """
         Create a task. See :func:`.create_task` for details.
         """
         try:
-            if name in self.tasks:
-                raise ValueError(f"task with name '{name}' already exists")
             task = task_.Task(name, **kwargs)
+            if task.name in self.tasks:
+                raise ValueError(f"task with name '{task.name}' already exists")
             for context in reversed(self.contexts):
                 task = context.apply(task)
                 if task is None:
                     raise ValueError(f"{context} did not return a task")
-            self.tasks[name] = task
+            self.tasks[task.name] = task
             return task
-        except:  # noqa: 722
+        except:
             filename, lineno = util.get_location()
             LOGGER.exception(
                 "failed to create task with name '%s' at %s:%d", name, filename, lineno
@@ -135,7 +137,7 @@ class Manager:
 
 
 def create_task(
-    name: str,
+    name: str | None = None,
     *,
     action: "Action | str | None" = None,
     targets: list["Path | str"] | None = None,
@@ -147,7 +149,8 @@ def create_task(
     Create a new task.
 
     Args:
-        name: Name of the new task.
+        name: Name of the new task. Defaults to the string representation of the first
+            dependency if not provided.
         action: Action to execute or a string for shell commands.
         targets: Paths for files to be generated.
         dependencies: Paths to files on which this task depends.

cook/task.py

@@ -1,13 +1,21 @@
 from __future__ import annotations
-import colorama
+
+import asyncio
+import inspect
+import logging
 from pathlib import Path
 from typing import TYPE_CHECKING
-from . import util
 
+import colorama
+
+from . import util
 
 if TYPE_CHECKING:
-    from .util import PathOrStr
     from .actions import Action
+    from .util import PathOrStr
+
+
+LOGGER = logging.getLogger(__name__)
 
 
 class Task:
@@ -17,7 +25,7 @@ class Task:
 
     def __init__(
         self,
-        name: str,
+        name: str | None = None,
         *,
         dependencies: list["PathOrStr | Task"] | None = None,
         targets: list["PathOrStr"] | None = None,
@@ -25,16 +33,31 @@ class Task:
         task_dependencies: list[Task] | None = None,
         location: tuple[str, int] | None = None,
     ) -> None:
-        self.name = name
         self.dependencies = dependencies or []
+        if name is None:
+            if not self.dependencies:
+                raise ValueError("name is required if there are no dependencies")
+            name = str(self.dependencies[0])
+        self.name = name
         self.targets = [Path(path) for path in (targets or [])]
         self.action = action
         self.task_dependencies = task_dependencies or []
         self.location = location or util.get_location()
 
-    def execute(self, stop: util.StopEvent | None = None) -> None:
+    async def execute(self) -> None:
         if self.action:
-            self.action.execute(self, stop)
+            # Check if the action's execute method is actually async
+            # This handles custom actions that may have implemented sync execute()
+            if inspect.iscoroutinefunction(self.action.execute):
+                await self.action.execute(self)
+            else:
+                # User implemented old-style sync execute() - run in executor with warning
+                LOGGER.warning(
+                    f"{self.action.__class__.__name__} implements sync execute(); "
+                    "please update to async def execute() for better performance"
+                )
+                loop = asyncio.get_running_loop()
+                await loop.run_in_executor(None, self.action.execute, self)
 
     def __hash__(self) -> int:
         return hash(self.name)

cook/util.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
+
 import contextlib
-from datetime import datetime, timedelta
 import hashlib
 import inspect
 import os
+from datetime import datetime, timedelta
 from pathlib import Path
-import threading
 from time import time
 from typing import TYPE_CHECKING, Generator
 
-
 if TYPE_CHECKING:
     from .task import Task
 
@@ -84,16 +83,6 @@ def get_location() -> tuple[Path, int]:
     return Path(frame.f_code.co_filename).resolve(), frame.f_lineno
 
 
-class StopEvent(threading.Event):
-    """
-    Event used for stopping execution with a polling interval.
-    """
-
-    def __init__(self, interval: float = 1) -> None:
-        super().__init__()
-        self.interval = interval
-
-
 def format_timedelta(delta: timedelta) -> str:
     """
     Format a time difference.

{cook_build-0.6.4.dist-info → cook_build-0.7.0.dist-info}/METADATA

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

cook_build-0.7.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+cook/__init__.py,sha256=SCa9_i6B84IzSAwq0wnSQqvycyL4dvTO7dRIysJXZj4,179
+cook/__main__.py,sha256=4sO22TsNTt3oirT71dJjZJwmynsRyUGT-CHJNlDgCkk,13242
+cook/actions.py,sha256=1VLyWL-pACuWpAjIyNWPBeu6wlKkoqi6t3lHr6hV0EQ,7399
+cook/contexts.py,sha256=AMKO7Uz-nI52OsdPQ_zCLXjOf77V4pgzvDyj6-N8Ods,10705
+cook/controller.py,sha256=vpF3QhiM3HImaI0rHJ58T8i5AQi5_P4Z2p42qFvG1po,13426
+cook/manager.py,sha256=Y-QGVw9x8ZpSBMRALJIHgcMmIZulAV9KxwtBJz35Gpw,6241
+cook/task.py,sha256=2UsXJiPe7htnlFqAKYm3Ot3bz9jXGHm3qfeqh6l5alM,2320
+cook/util.py,sha256=15MMG07CYZZ-YdFE_2jzRRTaqHMsw83UFg0s7e72MhI,2435
+cook_build-0.7.0.dist-info/licenses/LICENSE,sha256=3Nuj_WTTcz7JDg4-9EzNf6vHlKRWpdLUccg-pvoZ3WE,1500
+cook_build-0.7.0.dist-info/METADATA,sha256=j_WuF101Muusbbdrw_w8lv-pB_p0bEJbBuUZLUh8V30,4586
+cook_build-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cook_build-0.7.0.dist-info/entry_points.txt,sha256=5UP0ZmmxSNKevTVISUJxmdXEQsKrI4n54OQYkjrdX2c,48
+cook_build-0.7.0.dist-info/top_level.txt,sha256=ewNQIn2oRSYV98vAsUnw88u2Q8XHKhAz70ed2PEdR2c,5
+cook_build-0.7.0.dist-info/RECORD,,

cook_build-0.6.4.dist-info/RECORD

@@ -1,14 +0,0 @@
-cook/__init__.py,sha256=uNRvyxT6-XuoAMdDujWYa_4ZW0ppAiom6tsxMovZ-A0,180
-cook/__main__.py,sha256=s0OlqS5mjynGclvczksty2Cf8JgOGAdlBDmf2-2_D4g,13192
-cook/actions.py,sha256=erjjDKC45kQpv_Qb2V3OCGvrrphka4Ytj78RPEvs8Uc,6718
-cook/contexts.py,sha256=e3bddOaR8OLhPh38-U5b-u9D83NXlbQU0Hn7UvYaITI,10717
-cook/controller.py,sha256=g8UZS0lSGowO_lYXuF7BLxsAsmSCVtWNsJnWzLBCHdc,17376
-cook/manager.py,sha256=FAy8CKIMOx5liYNnaDTgnC5YZm1aqWy3pCIGiP8Hv2w,6118
-cook/task.py,sha256=ioPuQ8jp09BY9VhKn2cC6Q8G17W-1e4q4kj2GD4Zs8k,1388
-cook/util.py,sha256=hpMxxHnmJRfCUUAzkwMQU4kF_JAcEBFVpvPsHxOOY2U,2681
-cook_build-0.6.4.dist-info/licenses/LICENSE,sha256=3Nuj_WTTcz7JDg4-9EzNf6vHlKRWpdLUccg-pvoZ3WE,1500
-cook_build-0.6.4.dist-info/METADATA,sha256=_BpZNGF-uitiE4kVGjYnwbmyPMoY8KNy0djiXQNrl5I,4586
-cook_build-0.6.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cook_build-0.6.4.dist-info/entry_points.txt,sha256=5UP0ZmmxSNKevTVISUJxmdXEQsKrI4n54OQYkjrdX2c,48
-cook_build-0.6.4.dist-info/top_level.txt,sha256=ewNQIn2oRSYV98vAsUnw88u2Q8XHKhAz70ed2PEdR2c,5
-cook_build-0.6.4.dist-info/RECORD,,