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

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,8 @@
+from bake import Bakebook, console
+
+__bakebook__ = Bakebook()
+
+
+@__bakebook__.command()
+def hello(name: str = "world"):
+    console.echo(f"Hello {name}!")

bake/ui/__init__.py

@@ -0,0 +1,11 @@
+from bake.ui import console, params
+from bake.ui.logger.setup import setup_logging
+from bake.ui.run import run, run_uv
+
+__all__ = [
+    "console",
+    "params",
+    "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)

bake/ui/logger/__init__.py

@@ -0,0 +1,33 @@
+from loguru import logger
+
+from bake.ui.logger.capsys import (
+    capsys_to_logs,
+    capsys_to_logs_pretty,
+    capture_to_logs,
+    capture_to_logs_pretty,
+    count_message_in_logs,
+    find_log,
+    has_message_in_logs,
+    has_messages_in_logs,
+    parse_pretty_log,
+    strip_ansi,
+)
+from bake.ui.logger.setup import setup_logging
+from bake.ui.logger.utils import UNPARSABLE_LINE, LogKey
+
+__all__ = [
+    "UNPARSABLE_LINE",
+    "LogKey",
+    "capsys_to_logs",
+    "capsys_to_logs_pretty",
+    "capture_to_logs",
+    "capture_to_logs_pretty",
+    "count_message_in_logs",
+    "find_log",
+    "has_message_in_logs",
+    "has_messages_in_logs",
+    "logger",
+    "parse_pretty_log",
+    "setup_logging",
+    "strip_ansi",
+]

bake/ui/logger/capsys.py

@@ -0,0 +1,158 @@
+import json
+import re
+from typing import TYPE_CHECKING, Any
+
+import orjson
+
+from bake.ui.logger.utils import UNPARSABLE_LINE, LogKey, LogType
+
+if TYPE_CHECKING:
+    import _pytest.capture
+    import pytest
+
+
+def has_required_keys(log: LogType) -> bool:
+    return LogKey.required_keys().issubset(log.keys())
+
+
+def strip_ansi(text: str) -> str:
+    """Remove ANSI color codes from text."""
+    ansi_escape = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+    return ansi_escape.sub("", text)
+
+
+def _safe_parse_dict_str(dict_str: str, unparsed_key: str = "_unparsed") -> dict[str, Any]:
+    try:
+        return orjson.loads(dict_str)
+    except (TypeError, ValueError):
+        # For malformed JSON, preserve original string for debugging
+        return {unparsed_key: dict_str}
+
+
+def parse_pretty_log(pretty_output: str) -> list[LogType]:
+    """Parse pretty log format back into structured log entries."""
+    # Strip ANSI codes first
+    clean_output = strip_ansi(pretty_output)
+
+    log_pattern = re.compile(
+        r"(?P<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3} [+-]\d{2}:\d{2}) \| "
+        r"(?P<level>\w+)\s+\| "
+        r"(?P<name>[\w.]+):(?P<function>[\w_<>]+):(?P<line>\d+) - "
+        r"(?P<message>.+?) - "
+        r"(?P<extra>\{.*?\}) - "
+        r"(?P<default_extra>\{.*?\})"
+        r"(?:\n\n(?P<exception>Traceback[\s\S]*?))?(?=\n\n\d{4}-\d{2}-\d{2}|\n\d{4}-\d{2}-\d{2}|$)",
+        re.DOTALL,
+    )
+
+    matches = log_pattern.findall(clean_output)
+    parsed_logs = []
+    for match in matches:
+        # Unpack the match tuple (findall returns tuples, not match objects)
+        timestamp, level, name, function, line, message, extra, default_extra, exception = match
+
+        # Parse extra fields safely (handles non-literal values like PosixPath)
+        extra_dict = _safe_parse_dict_str(extra, "_unparsed_extra")
+        default_extra_dict = _safe_parse_dict_str(default_extra, "_unparsed_default_extra")
+
+        log_data = {
+            LogKey.TIMESTAMP.value: timestamp,
+            LogKey.LEVEL.value: level,
+            LogKey.NAME.value: name,
+            LogKey.MODULE.value: name.split(".")[-1],
+            LogKey.FUNCTION_NAME.value: function,
+            LogKey.LINE_NO.value: int(line),
+            LogKey.MESSAGE.value: message,
+            **extra_dict,
+            **default_extra_dict,
+        }
+
+        # Add exception if present
+        if exception:
+            log_data[LogKey.EXCEPTION.value] = exception
+
+        # Map default_extra to LogKey fields
+        if "process_name" in default_extra_dict:
+            log_data[LogKey.PROCESS_NAME.value] = default_extra_dict["process_name"]
+        if "file_name" in default_extra_dict:
+            log_data[LogKey.FILE_NAME.value] = default_extra_dict["file_name"]
+        if "thread_name" in default_extra_dict:
+            log_data[LogKey.THREAD_NAME.value] = default_extra_dict["thread_name"]
+
+        parsed_logs.append(log_data)
+
+    return parsed_logs
+
+
+def capture_to_logs(
+    capture: "_pytest.capture.CaptureResult[str]", preserve_unparsable: bool = False
+) -> list[LogType]:
+    log_lines = capture.err.strip().split("\n")
+    parsed_logs = []
+
+    for line in log_lines:
+        if not line:
+            continue
+        try:
+            parsed_log = json.loads(line)
+            if not has_required_keys(parsed_log):
+                if preserve_unparsable:
+                    parsed_logs.append({UNPARSABLE_LINE: line})
+                continue
+            parsed_logs.append(parsed_log)
+        except json.JSONDecodeError:
+            if preserve_unparsable:
+                parsed_logs.append({UNPARSABLE_LINE: line})
+            continue
+    return parsed_logs
+
+
+def capture_to_logs_pretty(capture: "_pytest.capture.CaptureResult[str]") -> list[LogType]:
+    pretty_output = capture.err
+    if not pretty_output.strip():
+        return []
+    return parse_pretty_log(pretty_output)
+
+
+def capsys_to_logs(
+    capsys: "pytest.CaptureFixture[str]", preserve_unparsable: bool = False
+) -> list[LogType]:
+    capture = capsys.readouterr()
+    return capture_to_logs(capture=capture, preserve_unparsable=preserve_unparsable)
+
+
+def capsys_to_logs_pretty(capsys: "pytest.CaptureFixture[str]") -> list[LogType]:
+    capture = capsys.readouterr()
+    return capture_to_logs_pretty(capture=capture)
+
+
+def has_message_in_logs(logs: list[LogType], message: str) -> bool:
+    return any(log for log in logs if re.search(message, log[LogKey.MESSAGE.value]))
+
+
+def has_messages_in_logs(logs: list[LogType], messages: list[str]) -> bool:
+    if not messages:
+        return True
+
+    log_messages = [log[LogKey.MESSAGE.value] for log in logs]
+    msg_idx = 0
+
+    for log_msg in log_messages:
+        if not re.search(messages[msg_idx], log_msg):
+            continue
+        msg_idx += 1
+        if msg_idx == len(messages):
+            return True
+
+    return False
+
+
+def count_message_in_logs(logs: list[LogType], message: str) -> int:
+    return sum(1 for log in logs if re.search(message, log[LogKey.MESSAGE.value]))
+
+
+def find_log(logs: list[LogType], pattern: str, index: int = 0) -> LogType:
+    matches = (log for log in logs if re.search(pattern, log[LogKey.MESSAGE.value]))
+    for _ in range(index):
+        next(matches)
+    return next(matches)