bakefile 0.0.4__tar.gz → 0.0.5__tar.gz

{bakefile-0.0.4 → bakefile-0.0.5}/PKG-INFO

@@ -1,12 +1,24 @@
 Metadata-Version: 2.3
 Name: bakefile
-Version: 0.0.4
+Version: 0.0.5
 Summary: Add your description here
 Author: Wisaroot Lertthaweedech
 Author-email: Wisaroot Lertthaweedech <l.wisaroot@gmail.com>
+Requires-Dist: beautysh>=6.4.2
+Requires-Dist: click>=8.3.1
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: orjson>=3.11.5
+Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pydantic>=2.12.5
-Requires-Dist: typer>=0.0.1
+Requires-Dist: rich>=14.2.0
+Requires-Dist: ruff>=0.14.10
+Requires-Dist: tomli>=2.0.0 ; python_full_version < '3.11'
+Requires-Dist: ty>=0.0.8
+Requires-Dist: typer>=0.21.0
+Requires-Dist: uv>=0.9.20
+Requires-Dist: pathspec>=1.0.3 ; extra == 'lib'
 Requires-Python: >=3.10
+Provides-Extra: lib
 Description-Content-Type: text/markdown
 
 [![tests](https://img.shields.io/github/actions/workflow/status/wislertt/bakefile/cd.yml?branch=main&label=tests&logo=github)](https://github.com/wislertt/bakefile/actions/workflows/cd.yml)

{bakefile-0.0.4 → bakefile-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bakefile"
-version = "0.0.4" # use git tag
+version = "0.0.5" # use git tag
 description = "Add your description here"
 readme = "README.md"
 authors = [
@@ -8,28 +8,52 @@ authors = [
 ]
 requires-python = ">=3.10"
 dependencies = [
+  "beautysh>=6.4.2",
+  "click>=8.3.1",
+  "loguru>=0.7.3",
+  "orjson>=3.11.5",
+  # "pathspec>=1.0.3",
+  "pydantic-settings>=2.0.0",
   "pydantic>=2.12.5",
-  "typer>=0.0.1"
+  "rich>=14.2.0",
+  "ruff>=0.14.10",
+  "tomli>=2.0.0; python_version < '3.11'",
+  "ty>=0.0.8",
+  "typer>=0.21.0",
+  "uv>=0.9.20"
+]
+
+[project.optional-dependencies]
+lib = [
+  "pathspec>=1.0.3"
 ]
 
 [project.scripts]
-bake = "bakefile.cli.bake:main"
-bakefile = "bakefile.cli.bakefile:app"
+bake = "bake.cli.bake:main"
+bakefile = "bake.cli.bakefile:main"
+bf = "bake.cli.bakefile:main"
 
 [dependency-groups]
 dev = [
+  "deptry>=0.24.0",
   "pre-commit>=4.5.1",
   "pytest-cov>=7.0.0",
   "pytest>=9.0.2",
-  "ruff>=0.14.10",
-  "toml-sort>=0.24.3",
-  "ty>=0.0.5"
+  "toml-sort>=0.24.3"
 ]
 
 [build-system]
 requires = ["uv_build>=0.9.18,<0.10.0"]
 build-backend = "uv_build"
 
+[tool.deptry]
+known_first_party = ["bake", "bakelib"]
+
+[tool.pytest.ini_options]
+markers = [
+  "integration: marks tests as integration tests (slower, full flow tests)"
+]
+
 [tool.ruff]
 line-length = 100
 
@@ -37,11 +61,11 @@ line-length = 100
 select = [
   "ARG",
   "B", # bugbear
-  "B9",
   "C4", # flake8-comprehensions
   "E", # pycodestyle (error)
   "F", # pyflakes
   "I", # isort
+  "N",
   "PGH", # pygrep-hooks
   "PIE", # flake8-pie
   "PYI", # flake8-pyi
@@ -49,3 +73,7 @@ select = [
   "SIM", # flake8-simplify
   "UP" # pyupgrade
 ]
+
+[tool.uv.build-backend]
+module-name = ["bake", "bakelib"]
+module-root = "src"

bakefile-0.0.5/src/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"]

bakefile-0.0.5/src/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,
+        )

bakefile-0.0.5/src/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

bakefile-0.0.5/src/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

bakefile-0.0.5/src/bake/cli/bake/__init__.py

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

bakefile-0.0.5/src/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()

bakefile-0.0.5/src/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)

bakefile-0.0.5/src/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)

bakefile-0.0.5/src/bake/cli/bakefile/__init__.py

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

bakefile-0.0.5/src/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()

bakefile-0.0.5/src/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}")

bakefile-0.0.5/src/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