cook-build 0.5.1__py3-none-any.whl → 0.6.1__py3-none-any.whl

cook/__main__.py

@@ -1,5 +1,6 @@
 import argparse
 import colorama
+from contextlib import closing
 from datetime import datetime
 import fnmatch
 import importlib.util
@@ -10,9 +11,13 @@ import re
 import sqlite3
 import sys
 import textwrap
-from typing import Iterable, List, Optional
+from typing import Iterable
 
-from .contexts import create_target_directories, normalize_action, normalize_dependencies
+from .contexts import (
+    create_target_directories,
+    normalize_action,
+    normalize_dependencies,
+)
 from .controller import Controller, QUERIES
 from .manager import Manager
 from .task import Task
@@ -23,22 +28,28 @@ LOGGER = logging.getLogger("cook")
 
 
 class NoMatchingTaskError(ValueError):
-    def __init__(self, patterns: Iterable[re.Pattern], hidden_tasks_available: bool):
+    def __init__(
+        self, patterns: Iterable[re.Pattern | str], hidden_tasks_available: bool
+    ) -> None:
         self.hidden_tasks_available = hidden_tasks_available
-        patterns = [f"`{pattern}`" for pattern in patterns]
-        if len(patterns) == 1:
-            message = f"found no tasks matching pattern {patterns[0]}"
+        formatted_patterns = [f"`{pattern}`" for pattern in patterns]
+        if len(formatted_patterns) == 1:
+            message = f"found no tasks matching pattern {formatted_patterns[0]}"
         else:
-            *patterns, last = patterns
-            message = "found no tasks matching patterns " + ", ".join(patterns) \
-                + (", or " if len(patterns) > 1 else " or ") + last
+            *formatted_patterns, last = formatted_patterns
+            message = (
+                "found no tasks matching patterns "
+                + ", ".join(formatted_patterns)
+                + (", or " if len(formatted_patterns) > 1 else " or ")
+                + last
+            )
         if hidden_tasks_available:
             message = message + "; use --all or -a to include hidden tasks"
         super().__init__(message)
 
 
 class Args:
-    tasks: Iterable[re.Pattern]
+    tasks: Iterable[re.Pattern | str]
     re: bool
     all: bool
 
@@ -47,23 +58,35 @@ class Command:
     """
     Abstract base class for commands.
     """
-    NAME: Optional[str] = None
+
+    NAME: str | None = None
     ALLOW_EMPTY_PATTERN: bool = False
 
     def configure_parser(self, parser: argparse.ArgumentParser) -> None:
-        parser.add_argument("--re", "-r", action="store_true",
-                            help="use regular expressions for pattern matching instead of glob")
-        parser.add_argument("--all", "-a", action="store_true",
-                            help="include tasks starting with `_` prefix")
-        parser.add_argument("tasks", nargs="*" if self.ALLOW_EMPTY_PATTERN else "+",
-                            help="task or tasks to execute as regular expressions or glob patterns")
+        parser.add_argument(
+            "--re",
+            "-r",
+            action="store_true",
+            help="use regular expressions for pattern matching instead of glob",
+        )
+        parser.add_argument(
+            "--all",
+            "-a",
+            action="store_true",
+            help="include tasks starting with `_` prefix",
+        )
+        parser.add_argument(
+            "tasks",
+            nargs="*" if self.ALLOW_EMPTY_PATTERN else "+",
+            help="task or tasks to execute as regular expressions or glob patterns",
+        )
 
     def execute(self, controller: Controller, args: argparse.Namespace) -> None:
         raise NotImplementedError
 
-    def discover_tasks(self, controller: Controller, args: Args) -> List[Task]:
+    def discover_tasks(self, controller: Controller, args: Args) -> list[Task]:
         task: Task
-        tasks: List[Task] = []
+        tasks: list[Task] = []
 
         # Get tasks based on the pattern matching.
         if not args.tasks:
@@ -73,7 +96,10 @@ class Command:
                 if args.re:
                     match = any(re.match(pattern, task.name) for pattern in args.tasks)
                 else:
-                    match = any(fnmatch.fnmatch(task.name, pattern) for pattern in args.tasks)
+                    match = any(
+                        fnmatch.fnmatch(task.name, pattern)  # pyright: ignore[reportArgumentType]
+                        for pattern in args.tasks
+                    )
                 if match:
                     tasks.append(task)
 
@@ -83,8 +109,11 @@ class Command:
         # Filter out hidden tasks if desired unless the name is an exact match to a specified
         # pattern.
         if not args.all:
-            tasks = [task for task in tasks if not task.name.startswith("_") or task.name in
-                     args.tasks]
+            tasks = [
+                task
+                for task in tasks
+                if not task.name.startswith("_") or task.name in args.tasks
+            ]
 
         if not tasks:
             raise NoMatchingTaskError(args.tasks, not args.all and has_hidden_task)
@@ -99,13 +128,16 @@ class ExecCommand(Command):
     """
     Execute one or more tasks.
     """
+
     NAME = "exec"
 
     def configure_parser(self, parser: argparse.ArgumentParser) -> None:
-        parser.add_argument("--jobs", "-j", help="number of concurrent jobs", type=int, default=1)
+        parser.add_argument(
+            "--jobs", "-j", help="number of concurrent jobs", type=int, default=1
+        )
         super().configure_parser(parser)
 
-    def execute(self, controller: Controller, args: ExecArgs) -> None:
+    def execute(self, controller: Controller, args: ExecArgs) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
         tasks = self.discover_tasks(controller, args)
         controller.execute(tasks, num_concurrent=args.jobs)
 
@@ -119,28 +151,43 @@ class LsCommand(Command):
     """
     List tasks.
     """
+
     NAME = "ls"
     ALLOW_EMPTY_PATTERN = True
 
     def configure_parser(self, parser: argparse.ArgumentParser) -> None:
-        parser.add_argument("--stale", "-s", action="store_true", help="only show stale tasks")
-        parser.add_argument("--current", "-c", action="store_true", help="only show current tasks")
+        parser.add_argument(
+            "--stale", "-s", action="store_true", help="only show stale tasks"
+        )
+        parser.add_argument(
+            "--current", "-c", action="store_true", help="only show current tasks"
+        )
         super().configure_parser(parser)
 
-    def execute(self, controller: Controller, args: LsArgs) -> None:
+    def execute(self, controller: Controller, args: LsArgs) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
         tasks = self.discover_tasks(controller, args)
-        tasks = [task.format(colorama.Fore.YELLOW if is_stale else colorama.Fore.GREEN)
-                 for is_stale, task in zip(controller.is_stale(tasks), tasks)]
+        tasks = [
+            task.format(colorama.Fore.YELLOW if is_stale else colorama.Fore.GREEN)
+            for is_stale, task in zip(controller.is_stale(tasks), tasks)
+        ]
         print("\n".join(tasks))
 
-    def discover_tasks(self, controller: Controller, args: LsArgs) -> List[Task]:
+    def discover_tasks(self, controller: Controller, args: LsArgs) -> list[Task]:  # pyright: ignore[reportIncompatibleMethodOverride]
         if args.current and args.stale:
-            raise ValueError("only one of `--stale` and `--current` may be given at the same time")
+            raise ValueError(
+                "only one of `--stale` and `--current` may be given at the same time"
+            )
         tasks = super().discover_tasks(controller, args)
         if args.stale:
-            return [task for stale, task in zip(controller.is_stale(tasks), tasks) if stale]
+            return [
+                task for stale, task in zip(controller.is_stale(tasks), tasks) if stale
+            ]
         elif args.current:
-            return [task for stale, task in zip(controller.is_stale(tasks), tasks) if not stale]
+            return [
+                task
+                for stale, task in zip(controller.is_stale(tasks), tasks)
+                if not stale
+            ]
         return tasks
 
 
@@ -148,6 +195,7 @@ class InfoCommand(LsCommand):
     """
     Display information about one or more tasks.
     """
+
     NAME = "info"
 
     def execute(self, controller: Controller, args: LsArgs) -> None:
@@ -166,21 +214,26 @@ class InfoCommand(LsCommand):
             ]
             # Show when the task last completed and failed.
             last = controller.connection.execute(
-                "SELECT last_completed, last_failed FROM tasks WHERE name = :name",
-                {"name": task.name}
-            ).fetchone() or (None, None)
-            for key, value in zip(["completed", "failed"], last):
+                "SELECT last_started, last_completed, last_failed FROM tasks WHERE name = :name",
+                {"name": task.name},
+            ).fetchone() or (None, None, None)
+            for key, value in zip(["started", "completed", "failed"], last):
                 if value is None:
                     parts.append(f"last {key}: -")
                     continue
-                parts.append(f"last {key}: {format_timedelta(datetime.now() - value)} ago "
-                             f"({format_datetime(value)})")
+                parts.append(
+                    f"last {key}: {format_timedelta(datetime.now() - value)} ago "
+                    f"({format_datetime(value)})"
+                )
             # Show dependencies and targets.
-            task_dependencies = list(sorted(controller.dependencies.successors(task),
-                                            key=lambda t: t.name))
+            task_dependencies = list(
+                sorted(controller.dependencies.successors(task), key=lambda t: t.name)
+            )
             task_dependencies = [
                 dep.format(colorama.Fore.YELLOW if is_stale else colorama.Fore.GREEN)
-                for is_stale, dep in zip(controller.is_stale(task_dependencies), task_dependencies)
+                for is_stale, dep in zip(
+                    controller.is_stale(task_dependencies), task_dependencies
+                )
             ]
             items = [
                 ("dependencies", task.dependencies),
@@ -195,22 +248,22 @@ class InfoCommand(LsCommand):
                     parts.append(f"{key}: -")
             parts.append(f"action: {task.action if task.action else '-'}")
 
-            parts = textwrap.indent('\n'.join(parts), indent)
+            parts = textwrap.indent("\n".join(parts), indent)
             print(f"{task}\n{parts}")
 
 
-class ResetArgs(argparse.Namespace):
-    tasks: Iterable[re.Pattern]
-    re: bool
+class ResetArgs(Args):
+    pass
 
 
 class ResetCommand(Command):
     """
     Reset the status of one or more tasks.
     """
+
     NAME = "reset"
 
-    def execute(self, controller: Controller, args: ResetArgs) -> None:
+    def execute(self, controller: Controller, args: ResetArgs) -> None:  # pyright: ignore[reportIncompatibleMethodOverride]
         tasks = self.discover_tasks(controller, args)
         controller.reset(*tasks)
 
@@ -233,14 +286,26 @@ class Formatter(logging.Formatter):
         return formatted
 
 
-def __main__(cli_args: Optional[List[str]] = None) -> None:
+def __main__(cli_args: list[str] | None = None) -> None:
     parser = argparse.ArgumentParser("cook")
-    parser.add_argument("--recipe", help="file containing declarative recipe for tasks",
-                        default="recipe.py", type=Path)
-    parser.add_argument("--module", "-m", help="module containing declarative recipe for tasks")
-    parser.add_argument("--db", help="database for keeping track of assets", default=".cook")
-    parser.add_argument("--log-level", help="log level", default="info",
-                        choices={"error", "warning", "info", "debug"})
+    parser.add_argument(
+        "--recipe",
+        help="file containing declarative recipe for tasks",
+        default="recipe.py",
+        type=Path,
+    )
+    parser.add_argument(
+        "--module", "-m", help="module containing declarative recipe for tasks"
+    )
+    parser.add_argument(
+        "--db", help="database for keeping track of assets", default=".cook"
+    )
+    parser.add_argument(
+        "--log-level",
+        help="log level",
+        default="info",
+        choices={"error", "warning", "info", "debug"},
+    )
     subparsers = parser.add_subparsers()
     subparsers.required = True
 
@@ -258,11 +323,13 @@ def __main__(cli_args: Optional[List[str]] = None) -> None:
 
     with Manager() as manager:
         try:
-            manager.contexts.extend([
-                create_target_directories(),
-                normalize_action(),
-                normalize_dependencies(),
-            ])
+            manager.contexts.extend(
+                [
+                    create_target_directories(),
+                    normalize_action(),
+                    normalize_dependencies(),
+                ]
+            )
             if args.module:
                 # Temporarily add the current working directory to the path.
                 try:
@@ -273,17 +340,23 @@ def __main__(cli_args: Optional[List[str]] = None) -> None:
             elif args.recipe.is_file():
                 # Parse the recipe.
                 spec = importlib.util.spec_from_file_location("recipe", args.recipe)
+                assert spec, f"Could not load spec for '{args.recipe}'."
                 recipe = importlib.util.module_from_spec(spec)
+                assert spec.loader, f"Could not load recipe '{args.recipe}'."
                 spec.loader.exec_module(recipe)
             else:  # pragma: no cover
-                raise ValueError("recipe file or module must be specified; default recipe.py not "
-                                 "found")
+                raise ValueError(
+                    "recipe file or module must be specified; default recipe.py not "
+                    "found"
+                )
         except:  # noqa: E722
             LOGGER.fatal("failed to load recipe", exc_info=sys.exc_info())
             sys.exit(1)
 
-    with sqlite3.connect(args.db, detect_types=sqlite3.PARSE_DECLTYPES) as connection:
-        connection.executescript(QUERIES["schema"])
+    with closing(
+        sqlite3.connect(args.db, detect_types=sqlite3.PARSE_DECLTYPES)
+    ) as connection:
+        _setup_schema(connection)
         controller = Controller(manager.resolve_dependencies(), connection)
         command: Command = args.command
         try:
@@ -297,5 +370,15 @@ def __main__(cli_args: Optional[List[str]] = None) -> None:
             sys.exit(1)
 
 
+def _setup_schema(connection: sqlite3.Connection) -> None:
+    connection.executescript(QUERIES["schema"])
+    # Attempt to add the column which may not be present for cook versions <0.6.
+    try:
+        connection.execute("ALTER TABLE tasks ADD COLUMN last_started TIMESTAMP")
+    except sqlite3.OperationalError as ex:
+        if "duplicate column name" not in ex.args[0]:
+            raise  # pragma: no cover
+
+
 if __name__ == "__main__":
     __main__()

cook/actions.py

@@ -30,13 +30,14 @@ action; its return value is ignored. For example, the following action waits for
     >>> action.execute(None)
     time: 0.1...
 """
+
 import hashlib
 import os
 import shlex
 import subprocess
 import sys
 from types import ModuleType
-from typing import Callable, List, Optional, TYPE_CHECKING
+from typing import Callable, TYPE_CHECKING
 
 
 if TYPE_CHECKING:
@@ -48,14 +49,15 @@ class Action:
     """
     Action to perform when a task is executed in its own thread.
     """
-    def execute(self, task: "Task", stop: Optional["StopEvent"] = None) -> None:
+
+    def execute(self, task: "Task", stop: "StopEvent | None" = None) -> None:
         """
         Execute the action.
         """
         raise NotImplementedError
 
     @property
-    def hexdigest(self) -> Optional[str]:
+    def hexdigest(self) -> str | None:
         """
         Optional digest to check if an action changed.
         """
@@ -71,13 +73,14 @@ class FunctionAction(Action):
         *args: Additional positional arguments.
         **kwargs: Keyword arguments.
     """
+
     def __init__(self, func: Callable, *args, **kwargs) -> None:
         super().__init__()
         self.func = func
         self.args = args
         self.kwargs = kwargs
 
-    def execute(self, task: "Task", stop: Optional["StopEvent"] = None) -> None:
+    def execute(self, task: "Task", stop: "StopEvent | None" = None) -> None:
         self.func(task, *self.args, **self.kwargs)
 
 
@@ -101,11 +104,12 @@ class SubprocessAction(Action):
             >>> Path("hello.txt").is_file()
             True
     """
+
     def __init__(self, *args, **kwargs) -> None:
         self.args = args
         self.kwargs = kwargs
 
-    def execute(self, task: "Task", stop: Optional["StopEvent"] = None) -> None:
+    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)
@@ -116,14 +120,14 @@ class SubprocessAction(Action):
                     raise subprocess.CalledProcessError(returncode, process.args)
                 return
             except subprocess.TimeoutExpired:
-                if stop.is_set():
+                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))
+                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.
@@ -132,12 +136,14 @@ class SubprocessAction(Action):
                 pass
 
         # We couldn't kill the process. Also very unlikely.
-        raise subprocess.SubprocessError(f"failed to shut down {process}")  # pragma: no cover
+        raise subprocess.SubprocessError(
+            f"failed to shut down {process}"
+        )  # pragma: no cover
 
     @property
     def hexdigest(self) -> str:
         hasher = hashlib.sha1()
-        args, = self.args
+        (args,) = self.args
         if isinstance(args, str):
             hasher.update(args.encode())
         else:
@@ -148,7 +154,7 @@ class SubprocessAction(Action):
     def __repr__(self) -> str:
         args, *_ = self.args
         if not isinstance(args, str):
-            args = ' '.join(map(shlex.quote, args))
+            args = " ".join(map(shlex.quote, args))
         return f"{self.__class__.__name__}({repr(args)})"
 
 
@@ -159,15 +165,16 @@ class CompositeAction(Action):
     Args:
         *actions: Actions to execute.
     """
+
     def __init__(self, *actions: Action) -> None:
         self.actions = actions
 
-    def execute(self, task: "Task", stop: Optional["StopEvent"] = None) -> None:
+    def execute(self, task: "Task", stop: "StopEvent | None" = None) -> None:
         for action in self.actions:
             action.execute(task, stop)
 
     @property
-    def hexdigest(self) -> Optional[str]:
+    def hexdigest(self) -> str | None:
         parts = []
         for action in self.actions:
             hexdigest = action.hexdigest
@@ -188,7 +195,8 @@ class ModuleAction(SubprocessAction):
             being set).
         **kwargs: Keyword arguments for :class:`subprocess.Popen`.
     """
-    def __init__(self, args: List, debug: Optional[bool] = None, **kwargs) -> None:
+
+    def __init__(self, args: list, debug: bool | None = None, **kwargs) -> None:
         if kwargs.get("shell"):
             raise ValueError("shell execution is not supported by `ModuleAction`")
         if not args:

cook/contexts.py

@@ -29,10 +29,11 @@ Custom contexts can be implemented by inheriting from :class:`.Context` and impl
     >>> create_task("bar")
     <task `bar` @ ...>
 """
+
 from __future__ import annotations
 from pathlib import Path
 from types import ModuleType
-from typing import Callable, List, Optional, Tuple, TYPE_CHECKING
+from typing import Callable, TYPE_CHECKING
 from . import actions
 from . import manager as manager_
 from . import task as task_
@@ -51,14 +52,15 @@ class Context:
     Args:
         manager: Manager to which the context is added.
     """
-    def __init__(self, manager: Optional["Manager"] = None) -> None:
+
+    def __init__(self, manager: "Manager | None" = None) -> None:
         self.manager = manager or manager_.Manager.get_instance()
 
     def __enter__(self) -> Context:
         self.manager.contexts.append(self)
         return self
 
-    def __exit__(self, *_) -> None:
+    def __exit__(self, ex_type, ex_value, ex_traceback) -> None:
         if not self.manager.contexts:
             raise RuntimeError("exiting failed: no active contexts")
         if self.manager.contexts[-1] is not self:
@@ -109,8 +111,14 @@ class FunctionContext(Context):
             ...     create_task("baz")
             <task `bazbazbaz` @ ...>
     """
-    def __init__(self, func: Callable[["Task"], Task], *args, manager: Optional["Manager"] = None,
-                 **kwargs) -> None:
+
+    def __init__(
+        self,
+        func: Callable[["Task"], Task],
+        *args,
+        manager: "Manager | None" = None,
+        **kwargs,
+    ) -> None:
         super().__init__(manager)
         self.func = func
         self.args = args or ()
@@ -128,6 +136,7 @@ class create_target_directories(Context):
 
         This context is active by default.
     """
+
     def apply(self, task: "Task") -> Task:
         for target in task.targets:
             name = f"_create_target_directories:{target.parent}"
@@ -137,9 +146,12 @@ class create_target_directories(Context):
             # Create a task if necessary.
             create = self.manager.tasks.get(name)
             if create is None:
-                create = self.manager.create_task(name, action=actions.FunctionAction(
-                    lambda _: target.parent.mkdir(parents=True, exist_ok=True)
-                ))
+                create = self.manager.create_task(
+                    name,
+                    action=actions.FunctionAction(
+                        lambda _: target.parent.mkdir(parents=True, exist_ok=True)
+                    ),
+                )
             task.task_dependencies.append(create)
         return task
 
@@ -162,12 +174,13 @@ class normalize_action(Context):
 
         This context is active by default.
     """
+
     def apply(self, task: "Task") -> "Task":
         if isinstance(task.action, Callable):
             task.action = actions.FunctionAction(task.action)
         elif isinstance(task.action, str):
             task.action = actions.SubprocessAction(task.action, shell=True)
-        elif isinstance(task.action, List):
+        elif isinstance(task.action, list):
             if not task.action:
                 raise ValueError("action must not be an empty list")
             if all(isinstance(x, actions.Action) for x in task.action):
@@ -193,6 +206,7 @@ class normalize_dependencies(Context):
 
         This context is active by default.
     """
+
     def apply(self, task: "Task") -> "Task":
         # Move task and group dependencies to the task_dependencies if they appear in regular
         # dependencies.
@@ -200,10 +214,10 @@ 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)
+                task_dependencies.append(dependency)  # pyright: ignore[reportArgumentType]
             else:
                 dependencies.append(dependency)
-        task.dependencies = [Path(x) for x in dependencies]
+        task.dependencies = [Path(x) for x in dependencies]  # pyright: ignore[reportAttributeAccessIssue]
 
         # Unpack group dependencies and look up tasks by name.
         task_dependencies = []
@@ -244,11 +258,16 @@ class create_group(Context):
             >>> my_group
             <group `my_group` @ ... with 2 tasks>
     """
-    def __init__(self, name: str, manager: Optional["Manager"] = None,
-                 location: Optional[Tuple[str, int]] = None) -> None:
+
+    def __init__(
+        self,
+        name: str,
+        manager: "Manager | None" = None,
+        location: tuple[str, int] | None = None,
+    ) -> None:
         super().__init__(manager)
         self.name = name
-        self.task: Optional[task_.Task] = None
+        self.task: task_.Task | None = None
         self.location = location or util.get_location()
 
     def apply(self, task: "Task") -> "Task":