bakefile 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

bake/cli/bakefile/main.py

@@ -0,0 +1,41 @@
+from bake.cli.common.app import (
+    BakefileApp,
+    add_completion,
+    bake_app_callback_with_obj,
+    rich_markup_mode,
+)
+from bake.cli.common.obj import get_bakefile_object
+
+from . import uv
+from .add_inline import add_inline
+from .find_python import find_python
+from .init import init
+from .lint import lint
+
+
+def main():
+    bakefile_obj = get_bakefile_object(rich_markup_mode=rich_markup_mode)
+    bakefile_obj.setup_logging()
+    bakefile_obj.resolve_bakefile_path()
+
+    bakefile_app = BakefileApp(
+        add_completion=add_completion,
+        rich_markup_mode=rich_markup_mode,
+    )
+
+    uv_commands_context_settings = {
+        "allow_extra_args": True,
+        "ignore_unknown_options": True,
+    }
+
+    bakefile_app.callback(invoke_without_command=True)(bake_app_callback_with_obj(obj=bakefile_obj))
+    bakefile_app.command()(init)
+    bakefile_app.command()(add_inline)
+    bakefile_app.command()(find_python)
+    bakefile_app.command()(lint)
+    bakefile_app.command(context_settings=uv_commands_context_settings)(uv.sync)
+    bakefile_app.command(context_settings=uv_commands_context_settings)(uv.lock)
+    bakefile_app.command(context_settings=uv_commands_context_settings)(uv.add)
+    bakefile_app.command(context_settings=uv_commands_context_settings)(uv.pip)
+    bakefile_app.bakefile_object = bakefile_obj
+    bakefile_app()

bake/cli/bakefile/uv.py

@@ -0,0 +1,146 @@
+from typing import Annotated, Literal
+
+import typer
+
+from bake.cli.common.context import Context
+from bake.manage.run_uv import run_uv_add, run_uv_lock, run_uv_pip, run_uv_sync
+from bake.ui import console
+from bake.utils.exceptions import BakebookError, PythonNotFoundError
+
+PipCommand = Literal[
+    "compile",
+    "sync",
+    "install",
+    "uninstall",
+    "freeze",
+    "list",
+    "show",
+    "tree",
+    "check",
+]
+
+
+def pip(
+    ctx: Context,
+    command: Annotated[
+        PipCommand,
+        typer.Argument(help="UV pip subcommand"),
+    ],
+) -> None:
+    """
+    This runs `[bold cyan]uv pip <command> <args> --python <bakefile-python-path>[/bold cyan]`
+
+    For complete docs: `[cyan]uv pip --help[/cyan]`
+    """
+    bakefile_path = ctx.obj.bakefile_path
+    try:
+        cmd = [command, *ctx.args]
+        result = run_uv_pip(bakefile_path=bakefile_path, cmd=cmd, dry_run=ctx.obj.dry_run)
+        raise typer.Exit(result.returncode)
+    except (PythonNotFoundError, BakebookError) as e:
+        console.error(str(e))
+        raise typer.Exit(code=1) from None
+
+
+def add(ctx: Context) -> None:
+    """
+    This runs `[bold cyan]uv add --script bakefile.py <args>[/bold cyan]`
+
+    Requires PEP 723 inline metadata.
+
+    To add metadata: `[cyan]bakefile add-inline[/cyan]`
+    For project-level deps: `[cyan]uv add[/cyan]`
+    For complete docs: `[cyan]uv add --help[/cyan]`
+
+    Examples:
+        bakefile add requests typer
+        bakefile add "requests>=2.32.0" --dev
+    """
+    bakefile_path = ctx.obj.bakefile_path
+    args = ctx.args
+
+    try:
+        result = run_uv_add(bakefile_path=bakefile_path, cmd=args, dry_run=ctx.obj.dry_run)
+        raise typer.Exit(result.returncode)
+    except (PythonNotFoundError, BakebookError) as e:
+        console.error(str(e))
+        raise typer.Exit(code=1) from None
+
+
+def lock(
+    ctx: Context,
+    upgrade: Annotated[
+        bool,
+        typer.Option("--upgrade", "-U", help="Upgrade package dependencies"),
+    ] = False,
+) -> None:
+    """
+    This runs `[bold cyan]uv lock --script bakefile.py <args>[/bold cyan]`
+
+    Requires PEP 723 inline metadata.
+
+    To add metadata: `[cyan]bakefile add-inline[/cyan]`
+    For project-level deps: `[cyan]uv lock[/cyan]`
+    For complete docs: `[cyan]uv lock --help[/cyan]`
+
+    Examples:
+        bakefile lock
+        bakefile lock --upgrade
+        bakefile lock --no-build
+    """
+    bakefile_path = ctx.obj.bakefile_path
+    args = list(ctx.args)
+
+    if upgrade:
+        args.append("--upgrade")
+
+    try:
+        result = run_uv_lock(bakefile_path=bakefile_path, cmd=args, dry_run=ctx.obj.dry_run)
+        raise typer.Exit(result.returncode)
+    except (PythonNotFoundError, BakebookError) as e:
+        console.error(str(e))
+        raise typer.Exit(code=1) from None
+
+
+def sync(
+    ctx: Context,
+    upgrade: Annotated[
+        bool,
+        typer.Option("--upgrade", "-U", help="Upgrade package dependencies"),
+    ] = False,
+    reinstall: Annotated[
+        bool,
+        typer.Option("--reinstall", help="Reinstall all packages"),
+    ] = False,
+) -> None:
+    """
+    This runs `[bold cyan]uv sync --script bakefile.py <args>[/bold cyan]`
+
+    Requires PEP 723 inline metadata.
+
+    To add metadata: `[cyan]bakefile add-inline[/cyan]`
+    For project-level deps: `[cyan]uv sync[/cyan]`
+    For complete docs: `[cyan]uv sync --help[/cyan]`
+
+    Examples:
+        bakefile sync
+        bakefile sync --upgrade
+        bakefile sync --reinstall
+        bakefile sync --frozen
+        bakefile sync --no-dev
+        bakefile sync --no-build
+    """
+    bakefile_path = ctx.obj.bakefile_path
+    args = list(ctx.args)
+
+    if upgrade:
+        args.append("--upgrade")
+    if reinstall:
+        args.append("--reinstall")
+
+    try:
+        result = run_uv_sync(bakefile_path=bakefile_path, cmd=args, dry_run=ctx.obj.dry_run)
+        raise typer.Exit(result.returncode)
+    except (PythonNotFoundError, BakebookError) as e:
+        console.error(str(e))
+        raise typer.Exit(code=1) from None

bake/cli/common/app.py

@@ -0,0 +1,54 @@
+from collections.abc import Callable
+
+import typer
+from typer.core import MarkupMode
+
+from bake.cli.common.context import Context
+from bake.cli.common.params import (
+    bakebook_name_option,
+    chdir_option,
+    dry_run_option,
+    file_name_option,
+    is_chain_commands_option,
+    verbosity_option,
+    version_option,
+)
+from bake.ui import console
+from bake.utils.constants import (
+    DEFAULT_BAKEBOOK_NAME,
+    DEFAULT_CHDIR,
+    DEFAULT_FILE_NAME,
+    DEFAULT_IS_CHAIN_COMMAND,
+)
+
+from .obj import BakefileObject
+
+rich_markup_mode: MarkupMode = "rich" if not console.out.no_color else None
+add_completion = False
+
+
+class BakefileApp(typer.Typer):
+    bakefile_object: BakefileObject
+
+
+def show_help_if_no_command(ctx: Context) -> None:
+    if ctx.invoked_subcommand is None:
+        console.echo(ctx.get_help())
+        raise typer.Exit(1)
+
+
+def bake_app_callback_with_obj(obj: BakefileObject) -> Callable:
+    def bake_app_callback(
+        ctx: Context,
+        _chdir: chdir_option = DEFAULT_CHDIR,
+        _file_name: file_name_option = DEFAULT_FILE_NAME,
+        _bakebook_name: bakebook_name_option = DEFAULT_BAKEBOOK_NAME,
+        _version: version_option = False,
+        _is_chain_commands: is_chain_commands_option = DEFAULT_IS_CHAIN_COMMAND,
+        _verbosity: verbosity_option = 0,
+        _dry_run: dry_run_option = False,
+    ):
+        ctx.obj = obj
+        show_help_if_no_command(ctx)
+
+    return bake_app_callback

bake/cli/common/callback.py

@@ -0,0 +1,13 @@
+import typer
+
+
+def validate_file_name(file_name: str) -> str:
+    if "/" in file_name or "\\" in file_name:
+        raise typer.BadParameter(f"File name must not contain path separators: {file_name}")
+    if not file_name.endswith(".py"):
+        raise typer.BadParameter(f"File name must end with .py: {file_name}")
+    return file_name
+
+
+def validate_file_name_callback(value: str) -> str:
+    return validate_file_name(file_name=value)

bake/cli/common/context.py

@@ -0,0 +1,145 @@
+import subprocess
+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 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
+
+    @property
+    def verbosity(self) -> int:
+        return self.obj.verbosity
+
+    @property
+    def bakebook(self) -> "Bakebook | None":
+        return self.obj.bakebook
+
+    @overload
+    def run(
+        self,
+        cmd: str,
+        *,
+        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,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[str]: ...
+
+    @overload
+    def run(
+        self,
+        cmd: str,
+        *,
+        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,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[None]: ...
+
+    @overload
+    def run(
+        self,
+        cmd: list[str] | tuple[str, ...],
+        *,
+        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,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[str]: ...
+
+    @overload
+    def run(
+        self,
+        cmd: list[str] | tuple[str, ...],
+        *,
+        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,
+        **kwargs,
+    ) -> subprocess.CompletedProcess[None]: ...
+
+    def run(
+        self,
+        cmd: str | list[str] | tuple[str, ...],
+        *,
+        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,
+        **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,
+            **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,
+        **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,
+            **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,214 @@
+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:
+            if allow_missing:
+                return
+        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."
+    )