Bakebook

A Bakebook is a class in bakefile.py that holds your tasks:

Subclass it to share tasks across projects through normal inheritance.
It extends Pydantic’s BaseSettings, so configuration is typed class attributes with validation, env-var and .env loading, defaults, and type coercion.
Tasks use the @command() decorator, same syntax as Typer.
ctx.run() executes CLI commands through Python’s subprocess.

from bake import Bakebook, command, Context, console
from pydantic import Field
from typing import Annotated
import typer


class MyBakebook(Bakebook):
    # Pydantic configuration
    api_url: str = Field(default="https://api.example.com", env="API_URL")

    @command()
    def fetch(self) -> None:
        # Run CLI commands via self.ctx
        self.ctx.run(f"curl {self.api_url}")


bakebook = MyBakebook()


# Standalone functions also work
@bakebook.command()
def test(
    verbose: Annotated[bool, typer.Option(False, "--verbose", "-v")] = False,
):
    if verbose:
        console.echo("Running tests...")
    bakebook.ctx.run("pytest")

Defining tasks with @command

There are two patterns, depending on whether you define the task before or after instantiating the bakebook:

Pattern 1: Before instantiating - Use @command() on class methods, then access context through self.ctx.
Pattern 2: After instantiating - Use @bakebook.command() on standalone functions, then access context through bakebook.ctx.

@command() accepts all Typer options: name, help, deprecated, and so on.

from bake import Bakebook, command, console
from typing import Annotated
import typer


# Pattern 1: On class (use self.ctx for context access)
class MyBakebook(Bakebook):
    @command()
    def task1(self) -> None:
        console.echo("Task 1")
        self.ctx.run("echo 'Task 1 complete'")


bakebook = MyBakebook()


# Pattern 2: On instance (use bakebook.ctx for context access)
@bakebook.command(name="deploy", help="Deploy application")
def deploy(
    env: Annotated[str, typer.Option("dev", help="Environment to deploy")],
):
    console.echo(f"Deploying to {env}...")
    bakebook.ctx.run(f"kubectl apply -f {env}.yaml")

See Commands for typed arguments and decorator options, and Context for the full ctx.run reference.

Configuration with Pydantic settings

Because Bakebook extends BaseSettings, every class attribute is typed, validated configuration. Values load from environment variables, .env files, or defaults:

from bake import Bakebook
from pydantic import Field


class MyBakebook(Bakebook):
    # Defaults
    database_url: str = "sqlite:///db.sqlite3"

    # With environment variable mapping
    api_key: str = Field(default="default-key", env="API_KEY")

    # With validation
    port: int = Field(default=8000, ge=1, le=65535)

Tasks read settings as plain attributes (self.api_key), so configuration and the tasks that use it live in the same class. Inherited bakebooks inherit configuration too, and subclasses can override individual fields. See Settings for validation, secrets, and getting values out.

Reuse through inheritance

The point of Bakebook being a class: task libraries are just classes you inherit from.

from bake import Bakebook, command


class ProjectTasks(Bakebook):
    @command()
    def build(self) -> None:
        self.ctx.run("cargo build --release")


# In another project: inherit every task, override what differs
class AppTasks(ProjectTasks):
    version: str = "2.0.0"

    @command()
    def release(self) -> None:
        self.ctx.run(f"gh release create v{self.version}")

Override a task by redefining its method. Add tasks by defining new ones. Compose task sets through multiple inheritance. No include files, no templating, no copy-paste.

Instantiating

Create a bakebook by inheriting from Bakebook or instantiating it directly:

from bake import Bakebook

bakebook = Bakebook()

You can also generate a starter with bakefile init or bakefile add-inline.

Getting Started

Concepts

Usage

CLI Reference

bakelib

Examples

Troubleshooting

Defining tasks with @command

Configuration with Pydantic settings

Reuse through inheritance

Instantiating

​Defining tasks with @command

​Configuration with Pydantic settings

​Reuse through inheritance

​Instantiating

Defining tasks with @command

Configuration with Pydantic settings

Reuse through inheritance

Instantiating