bakefile 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

bake/cli/common/context.py

@@ -0,0 +1,145 @@
+import subprocess
+from collections.abc import Generator
+from contextlib import contextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal, overload
+
+import click
+import typer
+from typer.core import TyperCommand
+
+from bake.ui.run import CmdType
+from bake.ui.run import run as _run
+from bake.ui.run.script import run_script as _run_script
+
+from .obj import BakefileObject
+
+if TYPE_CHECKING:
+    from bake.bakebook.bakebook import Bakebook
+
+
+class Context(typer.Context):
+    obj: BakefileObject
+
+    @property
+    def dry_run(self) -> bool:
+        return self.obj.dry_run
+
+    @dry_run.setter
+    def dry_run(self, value: bool) -> None:
+        self.obj.dry_run = value
+
+    @contextmanager
+    def override_dry_run(self, dry_run: bool) -> Generator[None, None, None]:
+        original = self.obj.dry_run
+        self.obj.dry_run = dry_run
+        try:
+            yield
+        finally:
+            self.obj.dry_run = original
+
+    @property
+    def verbosity(self) -> int:
+        return self.obj.verbosity
+
+    @property
+    def bakebook(self) -> "Bakebook | None":
+        return self.obj.bakebook
+
+    @overload
+    def run(
+        self,
+        cmd: CmdType,
+        *,
+        capture_output: Literal[True] = True,
+        check: bool = True,
+        cwd: Path | str | None = None,
+        stream: bool = True,
+        shell: bool | None = None,
+        echo: bool = True,
+        dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[str]: ...
+
+    @overload
+    def run(
+        self,
+        cmd: CmdType,
+        *,
+        capture_output: Literal[False],
+        check: bool = True,
+        cwd: Path | str | None = None,
+        stream: bool = True,
+        shell: bool | None = None,
+        echo: bool = True,
+        dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[None]: ...
+
+    def run(
+        self,
+        cmd: CmdType,
+        *,
+        capture_output: bool = True,
+        check: bool = True,
+        cwd: Path | str | None = None,
+        stream: bool = True,
+        shell: bool | None = None,
+        echo: bool = True,
+        dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
+        _encoding: str | None = None,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+        return _run(
+            cmd,
+            capture_output=capture_output,
+            check=check,
+            cwd=cwd,
+            stream=stream,
+            shell=shell,
+            echo=echo,
+            dry_run=self.obj.dry_run if dry_run is None else dry_run,
+            keep_temp_file=keep_temp_file,
+            env=env,
+            _encoding=_encoding,
+            **kwargs,
+        )
+
+    def run_script(
+        self,
+        title: str,
+        script: str,
+        *,
+        capture_output: bool = True,
+        check: bool = True,
+        cwd: Path | str | None = None,
+        stream: bool = True,
+        echo: bool = True,
+        dry_run: bool | None = None,
+        keep_temp_file: bool = False,
+        env: dict[str, str] | None = None,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+        return _run_script(
+            title,
+            script,
+            capture_output=capture_output,
+            check=check,
+            cwd=cwd,
+            stream=stream,
+            echo=echo,
+            dry_run=self.obj.dry_run if dry_run is None else dry_run,
+            keep_temp_file=keep_temp_file,
+            env=env,
+            **kwargs,
+        )
+
+
+class BakeCommand(TyperCommand):
+    context_class: type[click.Context] = Context

bake/cli/common/exception_handler.py

@@ -0,0 +1,57 @@
+import errno
+import sys
+from contextlib import contextmanager
+from gettext import gettext
+from typing import TextIO, cast
+
+import click
+from typer.core import HAS_RICH, MarkupMode
+
+
+@contextmanager
+def typer_exception_handler(
+    *,
+    standalone_mode: bool,
+    rich_markup_mode: MarkupMode,
+):
+    # Reference code: https://github.com/fastapi/typer/blob/da9c4c67f3d8e4acd5f76e8909503bb999f1b751/typer/core.py#L186-L248
+    try:
+        try:
+            yield
+        except EOFError as e:
+            click.echo(file=sys.stderr)
+            raise click.Abort() from e
+        except KeyboardInterrupt as e:
+            raise click.exceptions.Exit(130) from e
+        except click.ClickException as e:
+            if not standalone_mode:
+                raise
+            if HAS_RICH and rich_markup_mode is not None:
+                from typer import rich_utils
+
+                rich_utils.rich_format_error(e)
+            else:
+                e.show()
+            sys.exit(e.exit_code)
+        except OSError as e:
+            if e.errno == errno.EPIPE:
+                sys.stdout = cast(TextIO, click.utils.PacifyFlushWrapper(sys.stdout))
+                sys.stderr = cast(TextIO, click.utils.PacifyFlushWrapper(sys.stderr))
+                sys.exit(1)
+            raise
+    except click.exceptions.Exit as e:
+        if standalone_mode:
+            sys.exit(e.exit_code)
+        else:
+            # return exit code to caller
+            raise
+    except click.Abort:
+        if not standalone_mode:
+            raise
+        if HAS_RICH and rich_markup_mode is not None:
+            from typer import rich_utils
+
+            rich_utils.rich_abort_error()
+        else:
+            click.echo(gettext("Aborted!"), file=sys.stderr)
+        sys.exit(1)

bake/cli/common/obj.py

@@ -0,0 +1,216 @@
+import contextlib
+import logging
+import os
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import click
+import typer
+from pydantic import ValidationError
+from rich.traceback import Traceback
+from typer.core import MarkupMode
+from typer.main import get_command_from_info
+
+from bake.bakebook.get import (
+    get_bakebook_from_target_dir_path,
+    resolve_bakefile_path,
+)
+from bake.ui import console, setup_logging
+from bake.utils.constants import (
+    DEFAULT_BAKEBOOK_NAME,
+    DEFAULT_CHDIR,
+    DEFAULT_FILE_NAME,
+    DEFAULT_IS_CHAIN_COMMAND,
+    GET_BAKEFILE_OBJECT,
+)
+from bake.utils.exceptions import BakebookError, BakefileNotFoundError
+
+from .callback import validate_file_name
+from .exception_handler import typer_exception_handler
+from .params import (
+    bakebook_name_option,
+    chdir_option,
+    dry_run_option,
+    file_name_option,
+    is_chain_commands_option,
+    remaining_args_argument,
+    verbosity_option,
+)
+
+if TYPE_CHECKING:
+    from bake.bakebook.bakebook import Bakebook
+
+logger = logging.Logger(__name__)
+
+
+@dataclass
+class BakefileObject:
+    chdir: Path
+    file_name: str
+    bakebook_name: str
+    bakefile_path: Path | None = None
+    bakebook: "Bakebook | None" = None
+    verbosity: int = 0
+    dry_run: bool = False
+    remaining_args: list[str] | None = None
+    is_chain_commands: bool = False
+
+    def __post_init__(self):
+        validate_file_name(self.file_name)
+
+    def resolve_bakefile_path(self) -> Path | None:
+        if self.bakefile_path is not None:
+            return self.bakefile_path
+
+        with contextlib.suppress(BakefileNotFoundError):
+            self.bakefile_path = resolve_bakefile_path(chdir=self.chdir, file_name=self.file_name)
+
+        return self.bakefile_path
+
+    def get_bakebook(self, allow_missing: bool):
+        if self.bakebook is not None:
+            return
+
+        try:
+            if self.bakefile_path is None:
+                self.bakefile_path = resolve_bakefile_path(
+                    chdir=self.chdir, file_name=self.file_name
+                )
+            self.bakebook = get_bakebook_from_target_dir_path(
+                target_dir_path=self.bakefile_path, bakebook_name=self.bakebook_name
+            )
+        except BakefileNotFoundError as e:
+            if allow_missing:
+                return
+            console.error(str(e))
+            raise SystemExit(1) from e
+        except BakebookError as e:
+            if allow_missing:
+                return
+            exc_to_show = e.__cause__ if e.__cause__ else e
+
+            if exc_to_show.__class__ in {ValidationError, BakebookError}:
+                console.err.print(
+                    f"[bold red]{exc_to_show.__class__.__name__}:[/bold red]", end=" "
+                )
+                console.err.print(exc_to_show)
+                console.err.print(f"Searched in: {self.chdir.resolve()}\n")
+            else:
+                console.err.print(
+                    Traceback.from_exception(
+                        type(exc_to_show), exc_to_show, exc_to_show.__traceback__
+                    )
+                )
+            raise SystemExit(1) from e
+
+    def warn_if_no_bakebook(self, color_echo: bool):
+        if self.bakebook is None:
+            _ = color_echo  # Color handled by console module
+            console.warning(f"Bakebook `{self.bakebook_name}` not found in `{self.file_name}`")
+            console.echo(f"Searched in: {self.chdir.resolve()}\n")
+
+    def setup_logging(self):
+        level_map = {0: logging.WARNING, 1: logging.INFO, 2: logging.DEBUG}
+        log_level = level_map.get(self.verbosity, logging.WARNING)
+        setup_logging(level_per_module={"": log_level}, is_pretty_log=True)
+
+
+bakefile_obj_app = typer.Typer()
+
+
+def get_args(args: list[str] | None = None, windows_expand_args: bool = True) -> list[str]:
+    if args is None:
+        args = sys.argv[1:]
+
+        # Covered in Click tests
+        if os.name == "nt" and windows_expand_args:  # pragma: no cover
+            args = click.utils._expand_args(args)
+    else:
+        args = list(args)
+
+    return args
+
+
+def bakefile_obj_app_args(
+    args: list[str] | None = None,
+    windows_expand_args: bool = True,
+) -> list[str]:
+    # source from https://github.com/fastapi/typer/blob/b7f39eaad60141988f5d9a58df72c44d6128cd53/typer/core.py#L175-L185
+
+    args = get_args(args=args, windows_expand_args=windows_expand_args)
+
+    prohibited_non_bakefile_obj_app_args: list[str] = ["--help", "--version"]
+
+    args = [arg for arg in args if arg not in prohibited_non_bakefile_obj_app_args]
+    return args
+
+
+def is_bakebook_optional(remaining_args: list[str] | None) -> bool:
+    args = get_args()
+
+    some_args: list[str] = ["--help", "--version"]
+    is_some_args = len([arg for arg in args if arg in some_args]) > 0
+    return is_some_args or remaining_args is None or remaining_args == []
+
+
+@bakefile_obj_app.command(
+    name=GET_BAKEFILE_OBJECT,
+    hidden=True,
+    context_settings={
+        "allow_extra_args": True,
+        "allow_interspersed_args": False,
+        "ignore_unknown_options": True,
+    },
+)
+def _get_bakefile_object(
+    ctx: typer.Context,
+    chdir: chdir_option = DEFAULT_CHDIR,
+    file_name: file_name_option = DEFAULT_FILE_NAME,
+    bakebook_name: bakebook_name_option = DEFAULT_BAKEBOOK_NAME,
+    is_chain_commands: is_chain_commands_option = DEFAULT_IS_CHAIN_COMMAND,
+    remaining_args: remaining_args_argument = None,
+    verbosity: verbosity_option = 0,
+    dry_run: dry_run_option = False,
+):
+    _ = ctx
+    return BakefileObject(
+        chdir=chdir,
+        file_name=file_name,
+        bakebook_name=bakebook_name,
+        verbosity=verbosity,
+        dry_run=dry_run,
+        remaining_args=remaining_args,
+        is_chain_commands=is_chain_commands,
+    )
+
+
+def get_bakefile_object(rich_markup_mode: MarkupMode) -> BakefileObject:
+    with typer_exception_handler(standalone_mode=True, rich_markup_mode=rich_markup_mode):
+        args = bakefile_obj_app_args()
+
+        for registered_command in bakefile_obj_app.registered_commands:
+            if registered_command.name != GET_BAKEFILE_OBJECT:
+                continue
+
+            command = get_command_from_info(
+                registered_command,
+                pretty_exceptions_short=bakefile_obj_app.pretty_exceptions_short,
+                rich_markup_mode=bakefile_obj_app.rich_markup_mode,
+            )
+
+            with command.make_context(info_name=GET_BAKEFILE_OBJECT, args=args) as ctx:
+                bakefile_obj = command.invoke(ctx)
+                if not isinstance(bakefile_obj, BakefileObject):
+                    msg = (
+                        f"Expected `bakefile_obj` to be an instance of "
+                        f"{BakefileObject.__name__}, got {type(bakefile_obj).__name__}"
+                    )
+                    raise TypeError(msg)
+                return bakefile_obj
+
+    raise RuntimeError(
+        f"Failed to find the `{GET_BAKEFILE_OBJECT}` command in registered commands. "
+        f"This should never happen - please report this bug."
+    )

bake/cli/common/params.py

@@ -0,0 +1,72 @@
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from bake.cli.common.callback import validate_file_name_callback
+from bake.cli.utils.version import version_callback
+
+
+def verbosity_callback(_ctx: typer.Context, _param: typer.CallbackParam, value: int) -> int:
+    """Validate verbosity level (max 2)."""
+    if value > 2:
+        raise typer.BadParameter("Maximum verbosity is -vv")
+    return value
+
+
+# ==========================================================
+# Bakefile CLI Parameters
+# ==========================================================
+chdir_option = Annotated[
+    Path,
+    typer.Option(
+        "-C",
+        "--chdir",
+        help="Change directory before running",
+    ),
+]
+file_name_option = Annotated[
+    str,
+    typer.Option(
+        "--file-name",
+        "-f",
+        help="Path to bakefile.py",
+        callback=validate_file_name_callback,
+    ),
+]
+bakebook_name_option = Annotated[
+    str, typer.Option("--book-name", "-b", help="Name of bakebook object to retrieve")
+]
+version_option = Annotated[
+    bool,
+    typer.Option(
+        "--version",
+        help="Show version",
+        callback=version_callback,
+        is_eager=True,
+    ),
+]
+is_chain_commands_option = Annotated[bool, typer.Option("--chain", "-c", help="Chain commands")]
+remaining_args_argument = Annotated[list[str] | None, typer.Argument()]
+
+verbosity_option = Annotated[
+    int,
+    typer.Option(
+        "-v",
+        "--verbose",
+        help="Increase verbosity (-v for info, -vv for debug)",
+        count=True,
+        callback=verbosity_callback,
+    ),
+]
+dry_run_option = Annotated[
+    bool,
+    typer.Option("-n", "--dry-run", help="Dry run (show what would be done without executing)"),
+]
+
+# ==========================================================
+# Bakefile Local CLI Frequently Used Params
+# ==========================================================
+force_option = Annotated[
+    bool | None, typer.Option("--force/--no-force", "-f", help="Force execution")
+]

bake/cli/utils/version.py

@@ -0,0 +1,18 @@
+from importlib.metadata import PackageNotFoundError, version
+
+import typer
+
+from bake.ui import console
+
+
+def _get_version() -> str:
+    try:
+        return version("bakefile")
+    except PackageNotFoundError:
+        return "0.0.0"
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        console.out.print(_get_version(), style=None, highlight=False)
+        raise typer.Exit()

bake/manage/add_inline.py

@@ -0,0 +1,71 @@
+import logging
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+from bake.ui import console, run_uv
+from bake.utils.exceptions import BakebookError
+
+logger = logging.getLogger(__name__)
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    import tomli as tomllib  # type: ignore[import-not-found]
+
+
+def add_inline_metadata(bakefile_path: Path) -> None:
+    if not bakefile_path.exists():
+        logger.error(f"Bakefile not found at {bakefile_path}")
+        raise BakebookError(
+            f"Bakefile not found at {bakefile_path}. "
+            f"Run 'bakefile init --inline' to create a new bakefile with PEP 723 metadata."
+        )
+
+    result = run_uv(
+        ["init", "--script", str(bakefile_path.name)],
+        check=False,
+        cwd=bakefile_path.parent,
+        echo=False,
+    )
+
+    is_already_pep723 = result.returncode == 2 and "is already a PEP 723 script" in result.stderr
+
+    is_valid_output = result.returncode == 0 or is_already_pep723
+
+    if not is_valid_output:
+        command: str = " ".join(result.args)
+        logger.error(f"Failed to initialize PEP 723 metadata for {bakefile_path}")
+        raise BakebookError(
+            f"Failed to initialize PEP 723 metadata.\n\n"
+            f"Command: `{command}`\n\n"
+            f"Error: {result.stderr.strip()}"
+        )
+
+    if is_already_pep723:
+        console.warning(f"{bakefile_path.name} already has PEP 723 metadata")
+
+    run_uv(
+        ["add", "bakefile", "--script", str(bakefile_path.name)],
+        cwd=bakefile_path.parent,
+        echo=False,
+    )
+
+
+def read_inline(bakefile_path: Path) -> dict[str, Any] | None:
+    inline_regex = r"(?m)^# /// (?P<type>[a-zA-Z0-9-]+)$\s(?P<content>(^#(| .*)$\s)+)^# ///$"
+    script = bakefile_path.read_text()
+    name = "script"
+    matches = list(filter(lambda m: m.group("type") == name, re.finditer(inline_regex, script)))
+
+    if len(matches) > 1:
+        raise ValueError(f"Multiple {name} blocks found")
+    elif len(matches) == 1:
+        content = "".join(
+            line[2:] if line.startswith("# ") else line[1:]
+            for line in matches[0].group("content").splitlines(keepends=True)
+        )
+        return tomllib.loads(content)
+    else:
+        return None