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

bake/cli/bakefile/export.py

@@ -0,0 +1,212 @@
+import shlex
+from collections.abc import Callable, Hashable
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+import orjson
+import typer
+import yaml
+from pydantic_settings import BaseSettings
+
+from bake.cli.common.context import Context
+from bake.ui import console
+
+ExportFormat = Literal["sh", "dotenv", "json", "yaml"]
+JsonValue = str | float | bool | None | list[Any] | dict[Hashable, Any]
+
+
+def _format_shell_value(value: JsonValue) -> str:
+    """Format a value for shell export.
+
+    Expects JSON-serializable types (str, int, float, bool, None, list, dict).
+    Raises TypeError for unexpected types.
+
+    SecretStr values are masked for security.
+
+    Parameters
+    ----------
+    value : Any
+        The value to format for shell export
+
+    Returns
+    -------
+    str
+        Shell-formatted string ready for export
+
+    Raises
+    ------
+    TypeError
+        If value is not one of the expected types
+    """
+
+    if isinstance(value, (list, dict)):
+        # Complex types: JSON string, then shell-quote it
+        return shlex.quote(orjson.dumps(value).decode())
+    elif isinstance(value, str):
+        # Strings: shell-quote directly
+        return shlex.quote(value)
+    elif value is None:
+        # None becomes empty string
+        return ""
+    elif isinstance(value, bool):
+        # Booleans: lowercase true/false for shell compatibility
+        return str(value).lower()
+    elif isinstance(value, (int, float)):
+        # Numbers: convert to string, no quoting needed
+        return str(value)
+    raise TypeError(
+        f"Unexpected type for shell export: {type(value).__name__}. "
+        f"Expected one of: str, int, float, bool, None, list, dict"
+    )
+
+
+def _format_dotenv_value(value: JsonValue) -> str:
+    """Format a value for dotenv export.
+
+    Uses smart quote selection to produce valid dotenv format that
+    python-dotenv's parser can handle.
+
+    Parameters
+    ----------
+    value : JsonValue
+        The value to format for dotenv export
+
+    Returns
+    -------
+    str
+        Dotenv-formatted string ready for export
+
+    Raises
+    ------
+    TypeError
+        If value is not one of the expected types
+    """
+    if isinstance(value, (list, dict)):
+        # Complex types: JSON string, then wrap in double quotes
+        json_str = orjson.dumps(value).decode()
+        return '"' + json_str.replace("\\", "\\\\").replace('"', '\\"') + '"'
+    elif isinstance(value, str):
+        # Strings: use smart quote selection
+        if value.isalnum():
+            return value
+        if "'" in value and '"' not in value:
+            # Has single quotes only: use double quotes
+            return f'"{value}"'
+        if '"' in value and "'" not in value:
+            # Has double quotes only: use single quotes
+            return f"'{value}'"
+        # Has both or special chars: use double quotes with escaping
+        return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'
+    elif value is None:
+        return ""
+    elif isinstance(value, bool):
+        return str(value).lower()
+    elif isinstance(value, (int, float)):
+        return str(value)
+    raise TypeError(
+        f"Unexpected type for dotenv export: {type(value).__name__}. "
+        f"Expected one of: str, int, float, bool, None, list, dict"
+    )
+
+
+def _format_vars(data: dict, value_formatter: Callable[[JsonValue], str], prefix: str = "") -> str:
+    lines: list[str] = []
+    for field_name, value in data.items():
+        formatted_val = value_formatter(value)
+        lines.append(f"{prefix}{field_name.upper()}={formatted_val}")
+    return "\n".join(lines)
+
+
+class ExportFormatter:
+    def __call__(self, data: dict[str, Any]) -> str:
+        raise NotImplementedError("....")
+
+
+class ShExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return _format_vars(data, value_formatter=_format_shell_value, prefix="export ")
+
+
+class DotEnvExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return _format_vars(data, value_formatter=_format_dotenv_value, prefix="")
+
+
+class JsonExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return orjson.dumps(data, option=orjson.OPT_INDENT_2).decode()
+
+
+class YamlExportFormatter(ExportFormatter):
+    def __call__(self, data: dict[str, Any]) -> str:
+        return yaml.dump(data, default_flow_style=False, sort_keys=False)
+
+
+def _export(
+    bakebook: BaseSettings,
+    format: ExportFormat = "sh",
+    output: Path | None = None,
+) -> None:
+    formatters: dict[str, ExportFormatter] = {
+        "sh": ShExportFormatter(),
+        "dotenv": DotEnvExportFormatter(),
+        "json": JsonExportFormatter(),
+        "yaml": YamlExportFormatter(),
+    }
+
+    formatter = formatters.get(format)
+    if formatter is None:
+        raise ValueError(f"Unknown format: {format}")
+
+    data: dict[str, Any] = bakebook.model_dump(mode="json")
+    content = formatter(data)
+
+    if output:
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(content, encoding="utf-8")
+    elif content != "":
+        console.echo(content, overflow="ignore", crop=False)
+
+
+def export(
+    ctx: Context,
+    format: Annotated[
+        ExportFormat,
+        typer.Option(
+            "--format",
+            "-f",
+            help="Output format",
+        ),
+    ] = "sh",
+    output: Annotated[
+        Path | None,
+        typer.Option(
+            "--output",
+            "-o",
+            help="Output file path (default: stdout)",
+            exists=False,
+        ),
+    ] = None,
+) -> None:
+    """Export bakebook args to external formats.
+
+    Export Pydantic-validated bakebook args to various formats for use
+    outside Python runtime (shell scripts, GitHub Actions, .env files, etc.).
+
+    Examples:
+        # Export to shell for eval
+        bakefile export --format sh
+
+        # Export to dotenv file
+        bakefile export --format dotenv --output .env
+
+        # Export to JSON
+        bakefile export --format json --output config.json
+    """
+    if ctx.obj.bakebook is None:
+        ctx.obj.get_bakebook(allow_missing=False)
+
+    if ctx.obj.bakebook is None:
+        raise RuntimeError("Bakebook not found.")
+
+    _export(bakebook=ctx.obj.bakebook, format=format, output=output)

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

bake/cli/bakefile/main.py

@@ -0,0 +1,43 @@
+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 .export import export
+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()(export)
+    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 = True
+
+
+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)