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

bakelib/environ/base.py

@@ -0,0 +1,112 @@
+from typing import Any, ClassVar
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+
+class BaseEnv(str):
+    """BaseEnvironment string with comparison and Pydantic support.
+
+    Inherits from str to provide natural string behavior while adding
+    comparison operators for priority-based ordering.
+
+    ENV_ORDER is a list where each element is either:
+    - A string (normal priority, order matters)
+    - A set of strings (equal priority group)
+
+    Example: ["dev", "staging", {"prod", "share"}]
+    - "dev" has highest priority (index 0)
+    - "staging" has medium priority (index 1)
+    - "prod" and "share" have equal lowest priority (both in set at index 2)
+    """
+
+    ENV_ORDER: ClassVar[list[str | set[str]]] = ["dev", "staging", "prod"]
+
+    def __init__(self, value: str):
+        if not self._is_valid(value):
+            raise ValueError(
+                f"Invalid {self.__class__.__name__}: '{value}'. "
+                f"Must be one of: {self._flattened_env_order()}"
+            )
+
+    @classmethod
+    def _is_valid(cls, value: str) -> bool:
+        try:
+            cls._get_priority_index(value)
+            return True
+        except ValueError:
+            return False
+
+    @classmethod
+    def _flattened_env_order(cls) -> list[str]:
+        result: list[str] = []
+        for item in cls.ENV_ORDER:
+            if isinstance(item, set):
+                result.extend(sorted(item))
+            else:
+                result.append(item)
+        return result
+
+    @classmethod
+    def _get_priority_index(cls, value: str) -> int:
+        for idx, item in enumerate(cls.ENV_ORDER):
+            is_in_set = isinstance(item, set) and value in item
+            is_equal = item == value
+            if is_in_set or is_equal:
+                return idx
+        raise ValueError(f"Value '{value}' not found in ENV_ORDER")
+
+    def __lt__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        self_idx = self._get_priority_index(str(self))
+        other_idx = self._get_priority_index(str(other))
+        if self_idx != other_idx:
+            return self_idx < other_idx
+        # Same priority group, use alphabetical as tiebreaker
+        return str(self) < str(other)
+
+    def __le__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        return self < other or self == other
+
+    def __gt__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        return not (self < other) and self != other
+
+    def __ge__(self, other: str) -> bool:
+        if type(other) is not type(self):
+            return NotImplemented
+        return not (self < other)
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is not type(self):
+            return False
+        return str(self) == str(other)
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}('{self!s}')"
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source_type: Any, handler: GetCoreSchemaHandler
+    ) -> CoreSchema:
+        """Pydantic v2 integration for custom type validation."""
+        return core_schema.no_info_after_validator_function(cls, handler(str))
+
+    @classmethod
+    def validate(cls, v: object) -> "BaseEnv":
+        """Validate and convert input to BaseEnv."""
+        if isinstance(v, cls):
+            return v
+        if isinstance(v, str):
+            return cls(v)
+        raise ValueError(f"Cannot convert {type(v).__name__} to {cls.__name__}")

bakelib/environ/get_bakebook.py

@@ -0,0 +1,49 @@
+import os
+from typing import TypeVar
+
+from dotenv import load_dotenv as _load_dotenv
+
+from .bakebook import EnvBakebook
+
+# TODO: When min Python >= 3.12, use PEP 695 type parameter syntax:
+# def get_bakebook[E: EnvBakebook](bakebooks: list[E], ...) -> E:
+E = TypeVar("E", bound=EnvBakebook)
+
+
+def get_bakebook(
+    bakebooks: list[E],
+    *,
+    env_var_name: str = "ENV",
+    env_value: str | None = None,
+    load_dotenv: bool = True,
+) -> E:
+    if not bakebooks:
+        raise ValueError("bakebooks list cannot be empty")
+
+    # Convert to dict for O(1) lookup and duplicate detection
+    bakebooks_by_env: dict[str, E] = {}
+    for bb in bakebooks:
+        if not hasattr(bb, "env") or bb.env is None:
+            raise ValueError(f"All bakebooks must have an 'env' attribute. Found: {bb}")
+        env = str(bb.env)
+        if env in bakebooks_by_env:
+            raise ValueError(f"Duplicate env '{env}' found in bakebooks list")
+        bakebooks_by_env[env] = bb
+
+    # Get environment value
+    if env_value is None:
+        if load_dotenv:
+            _load_dotenv()
+        env_value = os.getenv(env_var_name)
+
+    # Env var not set - return lowest priority (min)
+    if env_value is None or env_value == "":
+        return bakebooks_by_env[str(min(bb.env for bb in bakebooks))]
+    # If env var is set, require exact match
+    elif env_value in bakebooks_by_env:
+        return bakebooks_by_env[env_value]
+
+    raise ValueError(
+        f"No bakebook found with env='{env_value}'. "
+        f"Available envs: {sorted(bakebooks_by_env.keys())}"
+    )

bakelib/environ/presets.py

@@ -0,0 +1,70 @@
+"""Preset environment configurations.
+
+This module contains pre-configured environment classes for common use cases.
+Users can also create their own environments by inheriting from BaseEnv.
+"""
+
+from typing import ClassVar
+
+from bakelib.environ.base import BaseEnv
+
+
+class GcpLandingZoneEnv(BaseEnv):
+    """GCP Landing Zone base environments.
+
+    Environment codes follow GCP Security Foundations Blueprint conventions:
+    https://docs.cloud.google.com/architecture/blueprints/security-foundations/summary
+
+    Environment Codes:
+    - d               - Development
+    - n               - Nonproduction
+    - p               - Production
+    - s               - Shared
+    - b               - Bootstrap
+    - c               - Common
+    - net             - Network
+
+    Tiers (ordered by priority, lower index = higher priority):
+    - d (development) - lowest priority
+    - n (nonprod)
+    - p/s/b/c/net     - highest priority, all equal (production + shared)
+
+    Example:
+        env = GcpLandingZoneEnv("d")
+        assert env < GcpLandingZoneEnv("n")
+        assert GcpLandingZoneEnv("n") < GcpLandingZoneEnv("p")
+    """
+
+    ENV_ORDER: ClassVar[list[str | set[str]]] = [
+        "d",
+        "n",
+        {"p", "s", "b", "c", "net"},
+    ]
+
+    def is_shared(self) -> bool:
+        return self.code in {"s", "b", "c", "net"}
+
+    @property
+    def name(self) -> str:
+        names = {
+            "d": "Development",
+            "n": "Nonproduction",
+            "p": "Production",
+            "s": "Shared",
+            "b": "Bootstrap",
+            "c": "Common",
+            "net": "Network",
+        }
+        return names[self.code]
+
+    @property
+    def code(self) -> str:
+        return str(self)
+
+    @property
+    def secondary_name(self) -> str:
+        return self.name if not self.is_shared() else "Shared"
+
+    @property
+    def secondary_code(self) -> str:
+        return self.code if not self.is_shared() else "s"

bakelib/space/base.py

@@ -0,0 +1,193 @@
+from pathlib import Path
+from typing import Annotated, Literal
+
+import orjson
+import typer
+
+from bake import Bakebook, Context, command
+from bake.ui import console
+
+from .utils import (
+    HOMWBREW_BIN,
+    LOCAL_BIN,
+    VENV_BIN,
+    PlatformType,
+    ToolInfo,
+    get_expected_paths,
+    get_platform,
+    remove_git_clean_candidates,
+    setup_brew,
+    setup_bun,
+    setup_uv,
+    setup_uv_tool,
+)
+
+
+class BaseSpace(Bakebook):
+    def _no_implementation(self, ctx: Context | None = None, *args, **kwargs):
+        _ = ctx, args, kwargs
+        console.error("No implementation")
+        raise typer.Exit(1)
+
+    @command(help="Run linters and formatters")
+    def lint(self, ctx: Context) -> None:
+        ctx.run('bunx prettier@latest --write "**/*.{js,jsx,ts,tsx,css,json,json5,yaml,yml,md\'}"')
+
+    @command(help="Run unit tests")
+    def test(self, ctx: Context) -> None:
+        self._no_implementation(ctx)
+
+    @command(help="Run integration tests")
+    def test_integration(self, ctx: Context) -> None:
+        self._no_implementation(ctx)
+
+    @command(help="Run all tests")
+    def test_all(self, ctx: Context) -> None:
+        self._no_implementation(ctx)
+
+    @command(help="Clean gitignored files with optional exclusions")
+    def clean(
+        self,
+        ctx: Context,
+        exclude_patterns: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--exclude-patterns",
+                "-e",
+                help="Patterns to exclude",
+            ),
+        ] = None,
+        use_default_excludes: Annotated[
+            bool,
+            typer.Option(
+                "--no-default-excludes",
+                help="Do not apply default exclude patterns",
+                is_flag=True,
+            ),
+        ] = False,
+    ) -> None:
+        results = ctx.run("git clean -fdX -n", stream=False, dry_run=False, echo=True)
+
+        exclude_patterns: set[str] = set(exclude_patterns if exclude_patterns else [])
+
+        if not use_default_excludes:
+            exclude_patterns |= {".env", ".cache"}
+
+        console.err.print(f"Exclude pattens: {exclude_patterns}")
+
+        remove_git_clean_candidates(
+            git_clean_dry_run_output=results.stdout,
+            exclude_patterns=exclude_patterns,
+            dry_run=ctx.dry_run,
+        )
+
+    @command(help="Clean all gitignored files")
+    def clean_all(self, ctx: Context) -> None:
+        ctx.run("git clean -fdX")
+
+    def setup_tool_managers(self, ctx: Context, platform: PlatformType) -> None:
+        _ = platform
+        setup_brew(ctx)
+
+    def setup_tools(self, ctx: Context, platform: PlatformType) -> None:
+        _ = platform
+        setup_bun(ctx)
+        setup_uv(ctx)
+        setup_uv_tool(ctx)
+
+    def setup_project(self, ctx: Context) -> None:
+        ctx.run("uv run pre-commit install")
+
+    @command(help="Setup development environment")
+    def setup_dev(self, ctx: Context) -> None:
+        platform = get_platform()
+        console.echo(f"Detected platform: {platform}")
+
+        if platform != "macos":
+            console.warning(f"Platform '{platform}' is not supported. Running in dry-run mode.")
+            overridden_dry_run = True
+        else:
+            overridden_dry_run = ctx.dry_run
+
+        with ctx.override_dry_run(overridden_dry_run):
+            self.clean(ctx=ctx)
+            self.setup_tool_managers(ctx=ctx, platform=platform)
+            self.setup_tools(ctx=ctx, platform=platform)
+            self.setup_project(ctx=ctx)
+
+    def _assert_which_path(
+        self,
+        ctx: Context,
+        tool_name: str,
+        tool_info: ToolInfo,
+    ) -> bool:
+        result = ctx.run(f"which {tool_name}", stream=False)
+        if ctx.dry_run:
+            return True
+        actual_path = Path(result.stdout.strip())
+
+        if actual_path in set(tool_info.expected_paths):
+            console.success(f"{tool_name}: {actual_path}")
+            return True
+
+        console.warning(f"{tool_name}: unexpected location (got {actual_path})")
+        return False
+
+    def _get_tools(self) -> dict[str, ToolInfo]:
+        return {
+            # homebrew only
+            "bun": ToolInfo(expected_paths=get_expected_paths("bun", {HOMWBREW_BIN})),
+            # homebrew or venv
+            "uv": ToolInfo(expected_paths=get_expected_paths("uv", {HOMWBREW_BIN, VENV_BIN})),
+            # local or venv
+            "bakefile": ToolInfo(
+                expected_paths=get_expected_paths("bakefile", {LOCAL_BIN, VENV_BIN})
+            ),
+            "pre-commit": ToolInfo(
+                expected_paths=get_expected_paths("pre-commit", {LOCAL_BIN, VENV_BIN})
+            ),
+        }
+
+    @command(help="List development tools")
+    def tools(
+        self,
+        ctx: Context,
+        format: Annotated[
+            Literal["json", "names"],
+            typer.Option("--format", "-f", help="Output format"),
+        ] = "json",
+    ) -> None:
+        _ = ctx
+        tools = self._get_tools()
+        if format == "json":
+            output: dict[str, dict[str, str | None]] = {k: v.model_dump() for k, v in tools.items()}
+            console.echo(orjson.dumps(output, option=orjson.OPT_INDENT_2).decode())
+        else:
+            console.echo("\n".join(sorted(tools.keys())))
+
+    @command(help="Assert development environment setup")
+    def assert_setup_dev(
+        self,
+        ctx: Context,
+        skip_test: Annotated[
+            bool,
+            typer.Option(
+                "--skip-test",
+                "-s",
+                help="Skip running tests",
+                is_flag=True,
+            ),
+        ] = False,
+    ) -> None:
+        tools = self._get_tools()
+        for tool_name, tool_info in tools.items():
+            self._assert_which_path(ctx, tool_name, tool_info)
+
+        self.lint(ctx)
+        if not skip_test:
+            self.test(ctx)
+
+    @command(help="Upgrade all dependencies")
+    def update(self, ctx: Context) -> None:
+        ctx.run("uv python upgrade")
+        ctx.run("uv tool upgrade --all")

bakelib/space/python.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+
+from bake import Context, params
+
+from .base import BaseSpace, ToolInfo
+from .utils import VENV_BIN, get_expected_paths
+
+
+def _get_python_version() -> str | None:
+    path = Path(".python-version")
+    if not path.exists():
+        return None
+    return path.read_text().strip()
+
+
+class PythonSpace(BaseSpace):
+    def _get_tools(self) -> dict[str, ToolInfo]:
+        tools = super()._get_tools()
+        tools["python"] = ToolInfo(
+            version=_get_python_version(),
+            expected_paths=list(get_expected_paths("python", {VENV_BIN})),
+        )
+        return tools
+
+    def lint(self, ctx: Context) -> None:
+        super().lint(ctx=ctx)
+
+        ctx.run(
+            "uv run toml-sort --sort-inline-arrays --in-place "
+            "--sort-first=project,dependency-groups pyproject.toml"
+        )
+        ctx.run("uv run ruff format --exit-non-zero-on-format .")
+        ctx.run("uv run ruff check --fix --exit-non-zero-on-fix .")
+        ctx.run("uv run ty check --error-on-warning --no-progress .")
+        ctx.run("uv run deptry .")
+
+    def _test(
+        self,
+        ctx: Context,
+        *,
+        tests_paths: str | list[str],
+        verbose: bool = False,
+        coverage_report: bool = True,
+    ) -> None:
+        paths = tests_paths if isinstance(tests_paths, str) else " ".join(tests_paths)
+
+        cmd = f"uv run pytest {paths}"
+
+        if coverage_report:
+            cmd += " --cov=src --cov-report=html --cov-report=term-missing --cov-report=xml"
+
+        if verbose:
+            cmd += " -s -v"
+
+        ctx.run(cmd)
+
+    def test_integration(
+        self,
+        ctx: Context,
+        verbose: params.verbose_bool = False,
+    ) -> None:
+        integration_tests_path = "tests/integration/"
+        if Path(integration_tests_path).exists():
+            tests_path = integration_tests_path
+            self._test(ctx, tests_paths=tests_path, verbose=verbose)
+        else:
+            self._no_implementation(ctx)
+
+    def test(self, ctx: Context) -> None:
+        unit_tests_path = "tests/unit/"
+        tests_path = unit_tests_path if Path(unit_tests_path).exists() else "tests/"
+        self._test(ctx, tests_paths=tests_path)
+
+    def test_all(self, ctx: Context) -> None:
+        unit_tests_path = "tests/unit/"
+        if Path(unit_tests_path).exists():
+            tests_path = "tests/"
+            self._test(ctx, tests_paths=tests_path)
+        else:
+            self._no_implementation(ctx)
+
+    def setup_project(self, ctx: Context) -> None:
+        super().setup_project(ctx=ctx)
+        ctx.run("uv sync --all-extras --all-groups --frozen")
+
+    def update(self, ctx: Context) -> None:
+        super().update(ctx=ctx)
+        ctx.run("uv lock --upgrade")
+        ctx.run("uv sync --all-extras --all-groups")

bakelib/space/utils.py

@@ -0,0 +1,118 @@
+import shutil
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import Literal
+
+import pathspec
+from pathspec.patterns.gitignore.basic import GitIgnoreBasicPattern
+from pydantic import BaseModel, Field
+
+from bake import Context
+from bake.ui import console
+
+
+def setup_brew(ctx: Context) -> None:
+    ctx.run("brew update")
+    ctx.run("brew upgrade")
+    ctx.run("brew cleanup")
+    ctx.run("brew list")
+    ctx.run("brew leaves")
+
+
+class ToolInfo(BaseModel):
+    version: str | None = None
+    expected_paths: list[Path] = Field(default_factory=list, exclude=True)
+
+
+class Platform(Enum):
+    MACOS = "macos"
+    LINUX = "linux"
+    WINDOWS = "windows"
+    OTHER = "other"
+
+
+PlatformType = Literal["macos", "linux", "windows", "other"]
+
+
+def get_platform() -> PlatformType:
+    if sys.platform == "darwin":
+        return Platform.MACOS.value
+    elif sys.platform == "linux":
+        return Platform.LINUX.value
+    elif sys.platform == "win32":
+        return Platform.WINDOWS.value
+    return Platform.OTHER.value
+
+
+def setup_uv(ctx: Context) -> None:
+    ctx.run("brew install uv")
+    ctx.run("uv python upgrade")
+    ctx.run("uv tool upgrade --all")
+    ctx.run("uv tool update-shell")
+
+
+def setup_bun(ctx: Context) -> None:
+    ctx.run("brew install oven-sh/bun/bun")
+
+
+def setup_uv_tool(ctx: Context) -> None:
+    ctx.run("uv tool install bakefile")
+    ctx.run("uv tool install pre-commit")
+
+
+HOMWBREW_BIN = Path("/opt/homebrew/bin")
+LOCAL_BIN = Path.home() / ".local" / "bin"
+VENV_BIN = Path.cwd() / ".venv" / "bin"
+
+
+def get_expected_paths(tool: str, locations: set[Path]) -> list[Path]:
+    return [loc / tool for loc in locations]
+
+
+def _skip_msg(path: Path, suffix: str, dry_run: bool) -> None:
+    verb = "Would skip" if dry_run else "Skipping"
+    console.echo(f"[yellow]~[/yellow] {verb} {suffix}{path}")
+
+
+def _remove_msg(path: Path, dry_run: bool) -> None:
+    verb = "Would remove" if dry_run else "Removing"
+    console.echo(f"[red]-[/red] [dim]{verb}[/dim] {path}")
+
+
+def _should_remove_path(path: Path, dry_run: bool) -> None:
+    _remove_msg(path, dry_run)
+    if dry_run:
+        return
+
+    if path.is_dir():
+        shutil.rmtree(path)
+    else:
+        path.unlink(missing_ok=True)
+
+
+def remove_git_clean_candidates(
+    git_clean_dry_run_output: str, exclude_patterns: set[str], dry_run: bool
+) -> None:
+    spec = pathspec.PathSpec.from_lines(
+        GitIgnoreBasicPattern,
+        exclude_patterns,
+    )
+
+    for line in git_clean_dry_run_output.splitlines():
+        line = line.strip()
+        if not line.startswith("Would remove "):
+            continue
+
+        rel_path = line.removeprefix("Would remove ").strip()
+        path = Path(rel_path)
+
+        if spec.match_file(rel_path):
+            _skip_msg(path, "", dry_run)
+            continue
+
+        if path.is_dir() and (path / ".git").exists():
+            _skip_msg(path, "git repository ", dry_run)
+            continue
+
+        _should_remove_path(path, dry_run)

bakefile/__init__.py

@@ -1,13 +0,0 @@
-from importlib.metadata import PackageNotFoundError, version
-
-__all__ = ["__version__"]
-
-
-def _get_version() -> str:
-    try:
-        return version("bakefile")
-    except PackageNotFoundError:
-        return "0.0.0"
-
-
-__version__ = _get_version()

bakefile/cli/bake/__init__.py

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