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

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

@@ -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.6.4 → cook_build-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cook-build"
-version = "0.6.4"
+version = "0.7.0"
 description = "A task-centric build system with simple declarative recipes specified in Python"
 readme = "README.md"
 license = {text = "BSD-3-Clause"}
@@ -39,6 +39,7 @@ dev = [
     "furo>=2025.9.25",
     "pyright>=1.1.406",
     "pytest>=8.4.2",
+    "pytest-asyncio>=0.24.0",
     "pytest-cov>=7.0.0",
     "ruff>=0.13.3",
     "sphinx>=7.4.7",

{cook_build-0.6.4 → cook_build-0.7.0}/src/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_build-0.6.4 → cook_build-0.7.0}/src/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_build-0.6.4 → cook_build-0.7.0}/src/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_build-0.6.4 → cook_build-0.7.0}/src/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