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

bake/__init__.py

@@ -0,0 +1,9 @@
+from bake.bakebook.bakebook import Bakebook
+from bake.bakebook.decorator import command
+from bake.cli.common.context import BakeCommand, Context
+from bake.cli.utils.version import _get_version
+from bake.ui import console
+
+__version__ = _get_version()
+
+__all__ = ["BakeCommand", "Bakebook", "Context", "__version__", "command", "console"]

bake/bakebook/bakebook.py

@@ -0,0 +1,85 @@
+import types
+from collections.abc import Callable
+from typing import Any
+
+import typer
+from pydantic import PrivateAttr
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typer.core import TyperCommand
+from typer.models import CommandFunctionType, Default
+
+from bake.cli.common.context import BakeCommand
+from bake.utils.constants import BAKE_COMMAND_KWARGS
+
+
+class Bakebook(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8", extra="ignore")
+    _app: typer.Typer = PrivateAttr(default_factory=typer.Typer)
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._register_marked_methods()
+
+    def _get_command_kwargs(self, method: types.MethodType) -> dict[str, Any] | None:
+        func = method.__func__
+
+        if hasattr(func, BAKE_COMMAND_KWARGS):
+            return object.__getattribute__(func, BAKE_COMMAND_KWARGS)
+
+        method_name = method.__name__
+        for base in self.__class__.__mro__[1:]:
+            if not hasattr(base, method_name):
+                continue
+            parent_func = getattr(base, method_name)
+            if hasattr(parent_func, BAKE_COMMAND_KWARGS):
+                return object.__getattribute__(parent_func, BAKE_COMMAND_KWARGS)
+
+        return None
+
+    def _register_marked_methods(self) -> None:
+        base_names = set(dir(BaseSettings()))
+        method_names = [
+            name for name in dir(self) if not name.startswith("_") and name not in base_names
+        ]
+        for name in method_names:
+            bound_method = getattr(self, name)
+            if not isinstance(bound_method, types.MethodType):
+                continue
+
+            cmd_kwargs = self._get_command_kwargs(bound_method)
+            if cmd_kwargs:
+                self._app.command(**cmd_kwargs)(bound_method)
+
+    def command(
+        self,
+        name: str | None = None,
+        *,
+        cls: type[TyperCommand] | None = None,
+        context_settings: dict[Any, Any] | None = None,
+        help: str | None = None,
+        epilog: str | None = None,
+        short_help: str | None = None,
+        options_metavar: str | None = None,
+        add_help_option: bool = True,
+        no_args_is_help: bool = False,
+        hidden: bool = False,
+        deprecated: bool = False,
+        rich_help_panel: str | None = Default(None),
+    ) -> Callable[[CommandFunctionType], CommandFunctionType]:
+        if cls is None:
+            cls = BakeCommand
+
+        return self._app.command(
+            name=name,
+            cls=cls,
+            context_settings=context_settings,
+            help=help,
+            epilog=epilog,
+            short_help=short_help,
+            options_metavar=options_metavar,
+            add_help_option=add_help_option,
+            no_args_is_help=no_args_is_help,
+            hidden=hidden,
+            deprecated=deprecated,
+            rich_help_panel=rich_help_panel,
+        )

bake/bakebook/decorator.py

@@ -0,0 +1,50 @@
+from collections.abc import Callable
+from typing import Any
+
+from typer.core import TyperCommand
+from typer.models import CommandFunctionType, Default
+
+from bake.cli.common.context import BakeCommand
+from bake.utils.constants import BAKE_COMMAND_KWARGS
+
+
+def command(
+    name: str | None = None,
+    *,
+    cls: type[TyperCommand] | None = None,
+    context_settings: dict[Any, Any] | None = None,
+    help: str | None = None,
+    epilog: str | None = None,
+    short_help: str | None = None,
+    options_metavar: str | None = None,
+    add_help_option: bool = True,
+    no_args_is_help: bool = False,
+    hidden: bool = False,
+    deprecated: bool = False,
+    rich_help_panel: str | None = Default(None),
+) -> Callable[[CommandFunctionType], CommandFunctionType]:
+    if cls is None:
+        cls = BakeCommand
+
+    def decorator(func: CommandFunctionType) -> CommandFunctionType:
+        object.__setattr__(
+            func,
+            BAKE_COMMAND_KWARGS,
+            {
+                "name": name,
+                "cls": cls,
+                "context_settings": context_settings,
+                "help": help,
+                "epilog": epilog,
+                "short_help": short_help,
+                "options_metavar": options_metavar,
+                "add_help_option": add_help_option,
+                "no_args_is_help": no_args_is_help,
+                "hidden": hidden,
+                "deprecated": deprecated,
+                "rich_help_panel": rich_help_panel,
+            },
+        )
+        return func
+
+    return decorator

bake/bakebook/get.py

@@ -0,0 +1,175 @@
+import importlib.util
+import logging
+import sys
+import types
+from collections.abc import Generator
+from contextlib import contextmanager
+from importlib.abc import Loader
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from bake.manage.find_python import is_standalone_bakefile
+from bake.manage.run_uv import run_uv_sync
+from bake.ui import console, style
+from bake.ui.run import run_uv
+from bake.utils.exceptions import BakebookError, BakefileNotFoundError
+
+if TYPE_CHECKING:
+    from bake.bakebook.bakebook import Bakebook
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar("T")
+
+
+@contextmanager
+def prepend_sys_path(path: str) -> Generator[None, None, None]:
+    path_existed = path in sys.path
+    if not path_existed:
+        sys.path.insert(0, path)
+    try:
+        yield
+    finally:
+        if not path_existed:
+            sys.path.remove(path)
+
+
+def get_target_dir_path(chdir: Path, create_if_not_exist: bool) -> Path:
+    if not chdir.exists():
+        if create_if_not_exist:
+            chdir.mkdir(parents=True, exist_ok=True)
+        else:
+            logger.debug(f"Directory not found: {chdir}")
+            raise BakefileNotFoundError(f"Directory not found: {chdir}")
+    if not chdir.is_dir():
+        logger.debug(f"Not a directory: {chdir}")
+        raise BakefileNotFoundError(f"Not a directory: {chdir}")
+    return chdir.resolve()
+
+
+def resolve_bakefile_path(chdir: Path, file_name: str) -> Path:
+    target_dir_path = get_target_dir_path(chdir=chdir, create_if_not_exist=False)
+    bakefile_path = target_dir_path / file_name
+    logger.debug(f"Resolve bakefile path: {bakefile_path}", extra={"bakefile_path": bakefile_path})
+    return bakefile_path
+
+
+def retry_load_module_with_uv_sync(
+    target_dir_path: Path,
+    error: ImportError,
+    parent_dir: str,
+    loader: Loader,
+    module: types.ModuleType,
+    dry_run: bool = False,
+):
+    logger.debug(f"Missing dependency: {error.name}. Running sync...")
+
+    sync_args = ["--all-groups", "--frozen", "--all-extras"]
+
+    if is_standalone_bakefile(target_dir_path):
+        # Standalone bakefile: use --script flag
+        run_uv_sync(
+            bakefile_path=target_dir_path,
+            cmd=sync_args,
+            dry_run=dry_run,
+        )
+    else:
+        # Project-level: use uv sync directly
+        run_uv(
+            ("sync", *sync_args),
+            cwd=parent_dir,
+            capture_output=True,
+            stream=True,
+            check=True,
+            echo=True,
+            dry_run=dry_run,
+        )
+
+    try:
+        loader.exec_module(module)
+    except Exception as e:
+        error_message = (
+            f"Failed get bakebook from: {target_dir_path} even after sync.\n"
+            f"{e.__class__.__name__}: {e}"
+        )
+        logger.debug(error_message)
+        console.error(
+            "Failed to load bakebook after dependency sync. "
+            f"Try running {style.code('uv cache clean')} to resolve potential caching issues."
+        )
+        raise BakebookError(error_message) from e
+
+
+def load_module(target_dir_path: Path) -> types.ModuleType:
+    if not target_dir_path.exists():
+        logger.debug(f"Directory not found: {target_dir_path}")
+        raise BakefileNotFoundError(f"Directory not found: {target_dir_path}")
+
+    parent_dir = str(target_dir_path.parent)
+    module_name = "bakefile"
+
+    with prepend_sys_path(parent_dir):
+        spec = importlib.util.spec_from_file_location(module_name, target_dir_path)
+        if spec is None or spec.loader is None:
+            logger.debug(f"Failed to load bakebook module from: {target_dir_path}")
+            raise BakebookError(f"Failed to load: {target_dir_path}")
+
+        module: types.ModuleType = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = module
+
+        try:
+            spec.loader.exec_module(module)
+        except ImportError as e:
+            retry_load_module_with_uv_sync(
+                target_dir_path=target_dir_path,
+                error=e,
+                parent_dir=parent_dir,
+                loader=spec.loader,
+                module=module,
+            )
+        except Exception as e:
+            error_message = (
+                f"Failed get bakebook from: {target_dir_path}.\n{e.__class__.__name__}: {e}"
+            )
+            logger.debug(error_message)
+            raise BakebookError(error_message) from e
+        return module
+
+
+def validate_bakebook(bakebook: Any, bakebook_name: str) -> "Bakebook":
+    from bake.bakebook.bakebook import Bakebook
+
+    if not isinstance(bakebook, Bakebook):
+        logger.debug(
+            f"Invalid bakebook type for '{bakebook_name}': "
+            f"expected {Bakebook.__name__}, got {type(bakebook).__name__}"
+        )
+        raise BakebookError(
+            f"Bakebook '{bakebook_name}' must be a {Bakebook.__name__}, "
+            f"got {type(bakebook).__name__}"
+        )
+
+    return bakebook
+
+
+def get_bakebook_from_module(
+    module: types.ModuleType, bakebook_name: str, target_dir_path: Path
+) -> "Bakebook":
+    if not hasattr(module, bakebook_name):
+        logger.debug(f"Bakebook '{bakebook_name}' not found in {target_dir_path}")
+        raise BakebookError(f"No '{bakebook_name}' found in {target_dir_path}")
+    bakebook = getattr(module, bakebook_name)
+    bakebook = validate_bakebook(bakebook=bakebook, bakebook_name=bakebook_name)
+    return bakebook
+
+
+def get_bakebook_from_target_dir_path(
+    target_dir_path: Path,
+    bakebook_name: str,
+) -> "Bakebook":
+    module = load_module(target_dir_path=target_dir_path)
+    bakebook = get_bakebook_from_module(
+        module=module, bakebook_name=bakebook_name, target_dir_path=target_dir_path
+    )
+    logger.debug(f"Successfully retrieved bakebook '{bakebook_name}' from {target_dir_path}")
+    return bakebook

bake/cli/bake/__init__.py

@@ -0,0 +1,3 @@
+from bake.cli.bake.main import main
+
+__all__ = ["main"]

bake/cli/bake/__main__.py

@@ -0,0 +1,5 @@
+# This enables: python -m bakefile.cli.bake
+# Standard Python pattern for running packages as modules
+from .main import main
+
+main()

bake/cli/bake/main.py

@@ -0,0 +1,74 @@
+import sys
+from contextlib import contextmanager
+
+import typer
+
+from bake.cli.bake.reinvocation import _reinvoke_with_detected_python
+from bake.cli.common.app import (
+    add_completion,
+    bake_app_callback_with_obj,
+    rich_markup_mode,
+)
+from bake.cli.common.obj import get_bakefile_object, is_bakebook_optional
+from bake.ui import console
+from bake.utils import env
+
+
+@contextmanager
+def set_argv(argv: list[str]):
+    original = sys.argv.copy()
+    sys.argv = argv
+    try:
+        yield
+    finally:
+        sys.argv = original
+
+
+def _run_chain_commands(remaining_args: list[str], prog_name: str, bake_app: typer.Typer) -> int:
+    exit_code = 0
+    for cmd in remaining_args:
+        try:
+            with set_argv([prog_name, cmd]):
+                console.cmd(" ".join(sys.argv))
+                bake_app(prog_name=prog_name)
+        except SystemExit as e:
+            if e.code is not None and e.code != 0:
+                exit_code = e.code if isinstance(e.code, int) else 1
+                break
+    return exit_code
+
+
+def main():
+    bakefile_obj = get_bakefile_object(rich_markup_mode=rich_markup_mode)
+    bakefile_obj.setup_logging()
+    bakefile_obj.resolve_bakefile_path()
+
+    # Check re-invocation with resolved bakefile path
+    # If re-invocation happens, process is replaced and we don't return
+    _reinvoke_with_detected_python(bakefile_obj.bakefile_path)
+    # If returned above, we're in the correct Python
+
+    bakefile_obj.get_bakebook(
+        allow_missing=is_bakebook_optional(remaining_args=bakefile_obj.remaining_args)
+    )
+
+    bakefile_obj.warn_if_no_bakebook(color_echo=env.should_use_colors())
+
+    bake_app = typer.Typer(
+        add_completion=add_completion,
+        rich_markup_mode=rich_markup_mode,
+    )
+
+    bake_app.callback(invoke_without_command=True)(bake_app_callback_with_obj(obj=bakefile_obj))
+
+    prog_name = "bake"
+
+    if bakefile_obj.bakebook is not None:
+        bake_app.add_typer(bakefile_obj.bakebook._app)
+
+    if bakefile_obj.is_chain_commands and bakefile_obj.remaining_args:
+        exit_code = _run_chain_commands(
+            remaining_args=bakefile_obj.remaining_args, prog_name=prog_name, bake_app=bake_app
+        )
+        raise SystemExit(exit_code)
+    bake_app(prog_name=prog_name)

bake/cli/bake/reinvocation.py

@@ -0,0 +1,63 @@
+import logging
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from bake.utils.env import _BAKE_REINVOKED
+
+logger = logging.getLogger(__name__)
+
+
+def _reinvoke_with_detected_python(bakefile_path: Path | None) -> None:
+    """Re-invoke bake CLI with detected Python if needed.
+
+    Checks if the current Python is the correct one for the bakefile.
+    If not, re-invokes the bake CLI with the detected Python using os.execve().
+
+    Args:
+        bakefile_path: Path to the bakefile, or None if not found
+
+    Returns:
+        None. Either calls os.execve() (replaces process) or returns normally.
+    """
+    # 1. Check marker to prevent infinite loops
+    if os.environ.get(_BAKE_REINVOKED):
+        logger.debug(
+            "Re-invocation marker set, skipping Python check",
+            extra={"sys.executable": sys.executable},
+        )
+        return
+
+    # 2. Try to find correct Python
+    try:
+        from bake.manage.find_python import find_python_path
+
+        python_path = find_python_path(bakefile_path)
+    except Exception:
+        logger.debug("Failed to find Python for bakefile, continuing with current Python")
+        return  # Continue with current Python
+
+    # 3. Compare with current Python (don't resolve symlinks - we want the venv Python)
+    current_python = Path(sys.executable)
+    target_python = python_path
+
+    if current_python == target_python:
+        logger.debug(f"Already using correct Python: {current_python}")
+        return  # Already correct
+
+    # 4. Re-invoke with detected Python
+    logger.debug(
+        f"Re-invoking bake with detected Python: {target_python} (current: {current_python})",
+        extra={"target_python": str(target_python)},
+    )
+    env = os.environ.copy()
+    env[_BAKE_REINVOKED] = "1"
+
+    sys.stdout.flush()
+    sys.stderr.flush()
+    result = subprocess.run(
+        [str(target_python), "-m", "bake.cli.bake", *sys.argv[1:]],
+        env=env,
+    )
+    raise SystemExit(result.returncode)

bake/cli/bakefile/__init__.py

@@ -0,0 +1,3 @@
+from bake.cli.bakefile.main import main
+
+__all__ = ["main"]

bake/cli/bakefile/__main__.py

@@ -0,0 +1,5 @@
+# This enables: python -m bakefile.cli.bakefile
+# Standard Python pattern for running packages as modules
+from .main import main
+
+main()

bake/cli/bakefile/add_inline.py

@@ -0,0 +1,29 @@
+import typer
+
+from bake.cli.common.context import Context
+from bake.manage.add_inline import add_inline_metadata
+from bake.ui import console, style
+from bake.utils.exceptions import BakebookError
+
+
+def add_inline(
+    ctx: Context,
+) -> None:
+    """Add PEP 723 inline metadata to bakefile.py.
+
+    For non-Python projects without pyproject.toml for dependency management.
+    """
+    if ctx.obj.bakefile_path is None or not ctx.obj.bakefile_path.exists():
+        console.error(
+            f"Bakefile not found at {ctx.obj.bakefile_path}. "
+            f"Run {style.code('bakefile init --inline')} to create one."
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        add_inline_metadata(ctx.obj.bakefile_path)
+    except BakebookError as e:
+        console.error(str(e))
+        raise typer.Exit(code=1) from None
+
+    console.success(f"Successfully added PEP 723 inline metadata to {ctx.obj.bakefile_path}")

bake/cli/bakefile/find_python.py

@@ -0,0 +1,18 @@
+import typer
+
+from bake.cli.common.context import Context
+from bake.manage.find_python import find_python_path
+from bake.ui import console
+from bake.utils.exceptions import PythonNotFoundError
+
+
+def find_python(
+    ctx: Context,
+) -> None:
+    """Find the Python interpreter path for the bakefile.py project."""
+    try:
+        python_path = find_python_path(ctx.obj.bakefile_path)
+        console.echo(python_path.as_posix())
+    except PythonNotFoundError as e:
+        console.error(str(e))
+        raise typer.Exit(code=1) from None

bake/cli/bakefile/init.py

@@ -0,0 +1,56 @@
+from typing import Annotated
+
+import typer
+
+from bake.bakebook.get import (
+    resolve_bakefile_path,
+)
+from bake.cli.common.context import Context
+from bake.cli.common.params import force_option
+from bake.manage.add_inline import add_inline_metadata
+from bake.manage.write_bakefile import write_bakefile
+from bake.samples import simple
+from bake.ui import console
+from bake.utils.exceptions import BakebookError
+
+
+def init(
+    ctx: Context,
+    force: force_option = False,
+    inline: Annotated[
+        bool, typer.Option("--inline", "-i", help="Create bakefile with PEP 723 inline metadata")
+    ] = False,
+) -> None:
+    """Create a new bakefile.py in the current directory."""
+
+    if ctx.obj.bakebook is not None and not force:
+        console.error("Bakebook already loaded. Use --force to override.")
+        raise typer.Exit(code=1)
+
+    ctx.obj.bakefile_path = resolve_bakefile_path(chdir=ctx.obj.chdir, file_name=ctx.obj.file_name)
+
+    if ctx.obj.bakefile_path.exists() and not force:
+        console.error(f"File already exists at {ctx.obj.bakefile_path}. Use --force to overwrite.")
+        raise typer.Exit(code=1)
+
+    write_bakefile(
+        bakefile_path=ctx.obj.bakefile_path,
+        bakebook_name=ctx.obj.bakebook_name,
+        sample_module=simple,
+    )
+    ctx.obj.get_bakebook(allow_missing=False)
+    assert ctx.obj.bakebook is not None
+
+    if inline:
+        try:
+            add_inline_metadata(ctx.obj.bakefile_path)
+        except BakebookError as e:
+            console.error(f"Failed to add PEP 723 metadata: {e}")
+            raise typer.Exit(code=1) from None
+
+        console.success(
+            f"Successfully created bakefile with PEP 723 metadata at {ctx.obj.bakefile_path}"
+        )
+        return
+
+    console.success(f"Successfully created bakefile at {ctx.obj.bakefile_path}")

bake/cli/bakefile/lint.py

@@ -0,0 +1,77 @@
+from typing import Annotated
+
+import typer
+
+from bake.cli.common.context import Context
+from bake.manage.find_python import find_python_path
+from bake.manage.lint import run_ruff_check, run_ruff_format, run_ty_check
+from bake.ui import console
+
+
+def lint(
+    ctx: Context,
+    only_bakefile: Annotated[
+        bool,
+        typer.Option("--only-bakefile", "-b", help="Only lint the bakefile, not entire project"),
+    ] = False,
+    ruff_format: Annotated[
+        bool,
+        typer.Option("--ruff-format/--no-ruff-format", show_default=False),
+    ] = True,
+    ruff_check: Annotated[
+        bool,
+        typer.Option("--ruff-check/--no-ruff-check", show_default=False),
+    ] = True,
+    ty_check: Annotated[
+        bool,
+        typer.Option("--ty/--no-ty", show_default=False),
+    ] = True,
+) -> None:
+    """
+    Quick and strict lint your bakefile.py.
+
+    Simple way to ensure your bakefile follows standard formatting
+    and type safety best practices. By default, also lints all Python
+    files in your project. For advanced linter configuration, use
+    ruff and ty directly.
+
+    By default, runs: ruff format, ruff check, ty check
+
+    Examples:
+        bakefile lint              # Lint bakefile.py and all Python files
+        bakefile lint -b           # Lint only bakefile.py
+        bakefile lint --no-ty      # Skip type checking
+    """
+    bakefile_path = ctx.obj.bakefile_path
+    if bakefile_path is None or not bakefile_path.exists():
+        console.error("Bakefile not found. Run 'bakefile init' first.")
+        raise typer.Exit(code=1)
+
+    if not any([ruff_format, ruff_check, ty_check]):
+        console.warning("All linters disabled. Nothing to do.")
+        raise typer.Exit(code=0)
+
+    try:
+        if ruff_format:
+            run_ruff_format(
+                bakefile_path, only_bakefile=only_bakefile, check=True, dry_run=ctx.obj.dry_run
+            )
+
+        if ruff_check:
+            run_ruff_check(
+                bakefile_path, only_bakefile=only_bakefile, check=True, dry_run=ctx.obj.dry_run
+            )
+
+        if ty_check:
+            python_path = find_python_path(bakefile_path)
+            run_ty_check(
+                bakefile_path,
+                python_path,
+                only_bakefile=only_bakefile,
+                check=True,
+                dry_run=ctx.obj.dry_run,
+            )
+    except typer.Exit as e:
+        if e.exit_code != 0:
+            console.error("Linting failed.")
+            raise typer.Exit(code=e.exit_code) from e