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

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

bake/manage/find_python.py

@@ -0,0 +1,210 @@
+import logging
+import re
+from pathlib import Path
+
+from bake.manage.add_inline import read_inline
+from bake.ui import run_uv
+from bake.utils import BakebookError
+from bake.utils.exceptions import PythonNotFoundError
+
+logger = logging.getLogger(__name__)
+
+
+def is_standalone_bakefile(bakefile_path: Path) -> bool:
+    inline_metadata = read_inline(bakefile_path)
+    if inline_metadata is None:
+        return False
+
+    dependencies = inline_metadata.get("dependencies", [])
+    has_bakefile = any(dep.startswith("bakefile") for dep in dependencies)
+
+    if not has_bakefile:
+        logger.error(
+            f"Invalid inline metadata in {bakefile_path}: "
+            f"PEP 723 metadata exists but 'bakefile' dependency is missing"
+        )
+        raise BakebookError(
+            f"Invalid inline metadata in {bakefile_path}: "
+            f"PEP 723 metadata exists but 'bakefile' dependency is missing. "
+            f"Run 'bakefile add-inline' to fix."
+        )
+
+    return True
+
+
+def _find_bakefile_lock(bakefile_path: Path) -> Path | None:
+    """Find bakefile-level lock (<bakefile.py.lock>)."""
+    lock_path = bakefile_path.with_suffix(bakefile_path.suffix + ".lock")
+    if lock_path.exists():
+        logger.debug(f"Found bakefile lock at {lock_path}")
+        return lock_path
+    logger.debug("No bakefile lock found")
+    return None
+
+
+def _find_project_lock(bakefile_path: Path) -> Path | None:
+    """Find project-level uv.lock by searching up directory tree."""
+    current_dir = bakefile_path.parent
+    for _ in range(10):  # Limit search depth
+        uv_lock = current_dir / "uv.lock"
+        if uv_lock.exists():
+            logger.debug(f"Found project lock at {uv_lock}")
+            return uv_lock
+        parent = current_dir.parent
+        if parent == current_dir:  # Reached root
+            break
+        current_dir = parent
+    logger.debug("No project lock found")
+    return None
+
+
+def _find_bakefile_python(bakefile_path: Path) -> Path | None:
+    # References:
+    #   https://github.com/astral-sh/uv/blob/543f1f3f5924d1d2734fd718381e6f0d0f6f70b5/crates/uv/src/commands/project/mod.rs#L843
+
+    kind = "script"
+    found_bakefile_level_venv_message = (
+        f"The {kind} environment's Python version satisfies the request"
+    )
+    result = run_uv(
+        ["python", "find", "--script", str(bakefile_path.name), "-v"],
+        check=False,
+        cwd=bakefile_path.parent,
+        echo=False,
+    )
+
+    is_bakefile_python_found = (
+        result.returncode == 0 and found_bakefile_level_venv_message in result.stderr.strip()
+    )
+
+    if is_bakefile_python_found:
+        python_path = Path(result.stdout.strip())
+        logger.debug(f"Found bakefile Python at {python_path.as_posix()}")
+        return python_path
+
+    logger.debug("No bakefile Python found")
+    return None
+
+
+def _find_project_python(bakefile_path: Path) -> Path | None:
+    """Find Python from project-level venv using uv python find -v."""
+    # References:
+    #   https://github.com/astral-sh/uv/blob/543f1f3f5924d1d2734fd718381e6f0d0f6f70b5/crates/uv-python/src/discovery.rs#L795
+    #   https://github.com/astral-sh/uv/blob/543f1f3f5924d1d2734fd718381e6f0d0f6f70b5/crates/uv-python/src/discovery.rs#L3169-L3184
+    result = run_uv(
+        ["python", "find", "-v"],
+        check=False,
+        cwd=bakefile_path.parent,
+        echo=False,
+    )
+
+    # Check if stderr contains "Found `...` at `...` (...)"
+    # where source is "active virtual environment" or "virtual environment"
+    stderr = result.stderr.strip()
+    pattern = r"Found `[^`]+` at `[^`]+` \(([^)]+)\)"
+    match = re.search(pattern, stderr)
+
+    if result.returncode == 0 and match:
+        source = match.group(1)
+        if source in {"active virtual environment", "virtual environment"}:
+            python_path = Path(result.stdout.strip())
+            logger.debug(f"Found project Python at {python_path} (source: {source})")
+            return python_path
+
+    logger.debug("No project Python found")
+    return None
+
+
+def _create_bakefile_venv(bakefile_path: Path) -> Path | None:
+    """Create bakefile-level venv and return Python path."""
+    lock_path = _find_bakefile_lock(bakefile_path)
+
+    if lock_path:
+        # Use frozen sync if lock exists
+        logger.debug("Syncing bakefile with frozen lock")
+        run_uv(
+            ["sync", "--script", str(bakefile_path.name), "--frozen"],
+            check=True,
+            cwd=bakefile_path.parent,
+            echo=False,
+        )
+    else:
+        # Create new lock and sync
+        logger.debug("Creating bakefile lock and syncing")
+        run_uv(
+            ["sync", "--script", str(bakefile_path.name)],
+            check=True,
+            cwd=bakefile_path.parent,
+            echo=False,
+        )
+        run_uv(
+            ["lock", "--script", str(bakefile_path.name)],
+            check=True,
+            cwd=bakefile_path.parent,
+            echo=False,
+        )
+
+    return _find_bakefile_python(bakefile_path)
+
+
+def _create_project_venv(bakefile_path: Path) -> Path | None:
+    """Create project-level venv and return Python path."""
+    work_dir = bakefile_path.parent
+
+    # Check if pyproject.toml exists
+    pyproject = work_dir / "pyproject.toml"
+    if not pyproject.exists():
+        logger.debug("No pyproject.toml found, cannot create project venv")
+        return None
+
+    lock_path = _find_project_lock(bakefile_path)
+
+    if lock_path:
+        # Use frozen sync if lock exists
+        logger.debug("Syncing project with frozen lock")
+        run_uv(["sync", "--frozen"], check=True, cwd=work_dir, echo=False)
+    else:
+        # Create new lock and sync
+        logger.debug("Creating project lock and syncing")
+        run_uv(["lock"], check=True, cwd=work_dir, echo=False)
+        run_uv(["sync"], check=True, cwd=work_dir, echo=False)
+
+    return _find_project_python(bakefile_path)
+
+
+def find_python_path(bakefile_path: Path | None) -> Path:
+    if bakefile_path is None or not bakefile_path.exists():
+        raise PythonNotFoundError(f"Bakefile not found at {bakefile_path}")
+
+    is_standalone = is_standalone_bakefile(bakefile_path)
+
+    if is_standalone:
+        logger.debug("Bakefile has inline metadata -> bakefile-level Python")
+
+        # Step 1: Try to find existing bakefile-level Python
+        python_path = _find_bakefile_python(bakefile_path)
+        if python_path:
+            return python_path
+
+        # Step 2: Create bakefile-level venv
+        python_path = _create_bakefile_venv(bakefile_path)
+        if python_path:
+            return python_path
+
+    else:
+        logger.debug("No inline metadata -> project-level Python")
+
+        # Step 1: Try to find existing project-level Python
+        python_path = _find_project_python(bakefile_path)
+        if python_path:
+            return python_path
+
+        # Step 2: Create project-level venv
+        python_path = _create_project_venv(bakefile_path)
+        if python_path:
+            return python_path
+
+    raise PythonNotFoundError(
+        f"Could not find Python for {bakefile_path}. "
+        f"Run 'bakefile add-inline' to add PEP 723 metadata for bakefile-level Python."
+    )

bake/manage/lint.py

@@ -0,0 +1,101 @@
+import logging
+import subprocess
+from pathlib import Path
+
+from ruff.__main__ import find_ruff_bin
+from ty.__main__ import find_ty_bin
+
+from bake.ui import console
+from bake.ui.run import run
+
+logger = logging.getLogger(__name__)
+
+
+def run_ruff(
+    bakefile_path: Path,
+    subcommand: str,
+    args: list[str],
+    *,
+    only_bakefile: bool = False,
+    check: bool = True,
+    dry_run: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    ruff_bin = find_ruff_bin()
+    target = bakefile_path.name if only_bakefile else "."
+    cmd = [subcommand, *args, target]
+    display_cmd = "ruff " + " ".join(cmd)
+    console.cmd(display_cmd)
+    return run(
+        [str(ruff_bin), *cmd],
+        cwd=bakefile_path.parent,
+        capture_output=True,
+        stream=True,
+        check=check,
+        echo=False,
+        dry_run=dry_run,
+    )
+
+
+def run_ruff_format(
+    bakefile_path: Path,
+    *,
+    only_bakefile: bool = False,
+    check: bool = True,
+    dry_run: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    return run_ruff(
+        bakefile_path=bakefile_path,
+        subcommand="format",
+        args=["--exit-non-zero-on-format"],
+        only_bakefile=only_bakefile,
+        check=check,
+        dry_run=dry_run,
+    )
+
+
+def run_ruff_check(
+    bakefile_path: Path,
+    *,
+    only_bakefile: bool = False,
+    check: bool = True,
+    dry_run: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    return run_ruff(
+        bakefile_path=bakefile_path,
+        subcommand="check",
+        args=[
+            "--fix",
+            "--exit-non-zero-on-fix",
+            "--extend-select",
+            "ARG,B,C4,E,F,I,N,PGH,PIE,PYI,RUF,SIM,UP",
+        ],
+        only_bakefile=only_bakefile,
+        check=check,
+        dry_run=dry_run,
+    )
+
+
+def run_ty_check(
+    bakefile_path: Path,
+    python_path: Path,
+    *,
+    only_bakefile: bool = False,
+    check: bool = True,
+    dry_run: bool = False,
+) -> subprocess.CompletedProcess[str]:
+    ty_bin = find_ty_bin()
+    cmd = ["check", "--error-on-warning", "--python", str(python_path)]
+    if only_bakefile:
+        cmd.append(bakefile_path.name)
+
+    display_cmd = "ty " + " ".join(cmd)
+    console.cmd(display_cmd)
+    return run(
+        [str(ty_bin), *cmd],
+        cwd=bakefile_path.parent,
+        capture_output=True,
+        stream=True,
+        check=check,
+        echo=False,
+        dry_run=dry_run,
+    )

bake/manage/run_uv.py

@@ -0,0 +1,88 @@
+import logging
+import subprocess
+from pathlib import Path
+
+from bake.manage.find_python import find_python_path, is_standalone_bakefile
+from bake.ui import console, style
+from bake.ui.run import run, run_uv
+from bake.utils import BakebookError
+from bake.utils.exceptions import PythonNotFoundError
+
+logger = logging.getLogger(__name__)
+
+
+def _run_uv(
+    bakefile_path: Path | None, command_name: str, cmd: list[str], dry_run: bool = False
+) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+    if bakefile_path is None or not bakefile_path.exists():
+        raise PythonNotFoundError(f"Bakefile not found at {bakefile_path}")
+
+    if not is_standalone_bakefile(bakefile_path):
+        error_msg = (
+            f"`{command_name}` command requires PEP 723 inline metadata in the bakefile. "
+            f"Run {style.code('bakefile add-inline')} to add metadata, "
+            f"or use {style.code(f'uv {command_name}')} directly for project-level dependencies."
+        )
+        raise BakebookError(error_msg)
+
+    logger.debug(f"Running `uv {command_name}` for {bakefile_path}")
+    result = run_uv(
+        (command_name, "--script", bakefile_path.name, *cmd),
+        capture_output=True,
+        stream=True,
+        check=True,
+        echo=True,
+        cwd=bakefile_path.parent,
+        dry_run=dry_run,
+    )
+    return result
+
+
+def run_uv_add(
+    bakefile_path: Path | None, cmd: list[str], dry_run: bool
+) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+    return _run_uv(bakefile_path=bakefile_path, command_name="add", cmd=cmd, dry_run=dry_run)
+
+
+def run_uv_lock(
+    bakefile_path: Path | None, cmd: list[str], dry_run: bool
+) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+    return _run_uv(bakefile_path=bakefile_path, command_name="lock", cmd=cmd, dry_run=dry_run)
+
+
+def run_uv_sync(
+    bakefile_path: Path | None, cmd: list[str], dry_run: bool
+) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+    return _run_uv(bakefile_path=bakefile_path, command_name="sync", cmd=cmd, dry_run=dry_run)
+
+
+def run_uv_pip(
+    bakefile_path: Path | None, cmd: list[str], dry_run: bool
+) -> subprocess.CompletedProcess[str] | subprocess.CompletedProcess[None]:
+    if bakefile_path is None or not bakefile_path.exists():
+        raise PythonNotFoundError(f"Bakefile not found at {bakefile_path}")
+
+    is_standalone = is_standalone_bakefile(bakefile_path)
+    if not is_standalone:
+        console.warning(
+            "No PEP 723 inline metadata found. Using project-level Python.\n"
+            f"For project-level dependencies, consider using {style.code('uv pip')} directly.\n"
+        )
+
+    python_path = find_python_path(bakefile_path)
+
+    version_result = run(
+        [str(python_path), "--version"], capture_output=True, stream=False, echo=False
+    )
+    version = version_result.stdout.strip() or version_result.stderr.strip()
+    console.err.print(f"Using {version}\n")
+
+    logger.debug(f"Running uv pip with cmd: {cmd}")
+    return run_uv(
+        ("pip", *cmd, "--python", str(python_path)),
+        capture_output=True,
+        stream=True,
+        check=True,
+        echo=True,
+        dry_run=dry_run,
+    )

bake/manage/write_bakefile.py

@@ -0,0 +1,20 @@
+import types
+from pathlib import Path
+
+from bake.utils.constants import BAKEBOOK_NAME_IN_SAMPLES
+
+
+def write_bakefile(
+    bakefile_path: Path, bakebook_name: str, sample_module: types.ModuleType
+) -> None:
+    if not hasattr(sample_module, BAKEBOOK_NAME_IN_SAMPLES):
+        raise ValueError(
+            f"Module `{sample_module.__name__}` must have `{BAKEBOOK_NAME_IN_SAMPLES}` attribute"
+        )
+
+    if sample_module.__file__ is None:
+        raise ValueError(f"Could not find `{sample_module.__name__}`")
+
+    original_bakefile_content = Path(sample_module.__file__).read_text()
+    customized_content = original_bakefile_content.replace(BAKEBOOK_NAME_IN_SAMPLES, bakebook_name)
+    bakefile_path.write_text(customized_content)

bake/samples/simple.py

@@ -0,0 +1,9 @@
+from bake.bakebook.bakebook import Bakebook
+from bake.ui import console
+
+__bakebook__ = Bakebook()
+
+
+@__bakebook__.command()
+def hello(name: str = "world"):
+    console.echo(f"Hello {name}!")

bake/ui/__init__.py

@@ -0,0 +1,10 @@
+from bake.ui import console
+from bake.ui.logger.setup import setup_logging
+from bake.ui.run import run, run_uv
+
+__all__ = [
+    "console",
+    "run",
+    "run_uv",
+    "setup_logging",
+]

bake/ui/console.py

@@ -0,0 +1,58 @@
+import textwrap
+from typing import Any
+
+from beautysh import BashFormatter
+from rich.console import Console
+
+out = Console(stderr=False)
+err = Console(stderr=True)
+
+BOLD_GREEN = "bold green"
+
+
+def _print(
+    console_obj: Console, emoji: str | None, label: str, style: str, message: str, **kwargs
+) -> None:
+    formatted_label = f"[{label}]" if console_obj.no_color or out.color_system is None else label
+
+    emoji = emoji + " " if emoji else ""
+    console_obj.print(f"[{style}]{emoji}{formatted_label}[/{style}] {message}", **kwargs)
+
+
+def success(message: str, **kwargs) -> None:
+    _print(out, ":white_check_mark:", "SUCCESS", BOLD_GREEN, message, **kwargs)
+
+
+def echo(message: Any, **kwargs) -> None:
+    out.print(message, **kwargs)
+
+
+def cmd(cmd_str: str, **kwargs) -> None:
+    err.print(f"[bold green]❯[/bold green] [default]{cmd_str}[/default]", **kwargs)  # noqa: RUF001
+
+
+def script_block(title: str, script: str, **kwargs) -> None:
+    formatter = BashFormatter()
+    formatted, error = formatter.beautify_string(script)
+
+    if error:
+        formatted = textwrap.dedent(script)
+
+    terminal_width: int = err.size.width
+    width = min(70, terminal_width)
+    bold_line = "━" * width
+    thin_line = "─" * width
+
+    err.print(bold_line, style=BOLD_GREEN)
+    err.print(title, style="bold")
+    err.print(thin_line, style=BOLD_GREEN)
+    err.print(formatted, highlight=False, **kwargs)
+    err.print(bold_line, style=BOLD_GREEN)
+
+
+def warning(message: str, **kwargs) -> None:
+    _print(err, ":warning-emoji: ", "WARNING", "bold yellow", message, **kwargs)
+
+
+def error(message: str, **kwargs) -> None:
+    _print(err, ":x:", "ERROR", "bold red", message, **kwargs)