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

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,80 @@
+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_path: str, verbose: bool = False) -> None:
+        cmd = (
+            f"uv run pytest {tests_path} --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_path=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_path=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_path=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"]

bakefile/cli/bake/main.py

@@ -1,127 +0,0 @@
-import typer
-from typer.main import get_command_from_info
-
-from bakefile import env
-from bakefile.cli.bake.resolve_bakebook import resolve_bakebook
-from bakefile.cli.utils.version import version_callback
-from bakefile.exceptions import BakebookError
-
-from .utils import get_bakebook_args
-
-rich_markup_mode = "rich" if env.should_use_colors() else None
-
-
-bake_app = typer.Typer(
-    add_completion=False,
-    rich_markup_mode=rich_markup_mode,
-)
-
-local_bake_app = typer.Typer(
-    add_completion=False,
-    rich_markup_mode=rich_markup_mode,
-)
-
-
-GET_BAKEBOOK = "get_bakebook"
-
-
-# Common option definitions (reused across callbacks and commands)
-chdir_option = typer.Option(None, "-C", "--chdir", help="Change directory before running")
-file_name_option = typer.Option("bakefile.py", "--file-name", "-f", help="Path to bakefile.py")
-bakebook_name_option = typer.Option(
-    "bakebook", "--book-name", "-b", help="Name of bakebook object to retrieve"
-)
-version_option = typer.Option(
-    False,
-    "--version",
-    help="Show version and exit",
-    callback=version_callback,
-    is_eager=True,
-)
-
-
-def show_help_if_no_command(ctx: typer.Context) -> None:
-    if ctx.invoked_subcommand is None:
-        typer.echo(ctx.get_help())
-
-
-@local_bake_app.callback(
-    invoke_without_command=True,
-)
-def local_bake_app_callback(
-    ctx: typer.Context,
-    _chdir: str = chdir_option,
-    _file_name: str = file_name_option,
-    _bakebook_name: str = bakebook_name_option,
-    _version: bool = version_option,
-):
-    show_help_if_no_command(ctx)
-
-
-@bake_app.callback(
-    invoke_without_command=True,
-)
-def bake_app_callback(
-    ctx: typer.Context,
-    _chdir: str = chdir_option,
-    _file_name: str = file_name_option,
-    _bakebook_name: str = bakebook_name_option,
-    _version: bool = version_option,
-):
-    show_help_if_no_command(ctx)
-
-
-@bake_app.command(
-    name=GET_BAKEBOOK,
-    hidden=True,
-    context_settings={
-        "allow_extra_args": True,
-        "allow_interspersed_args": False,
-        "ignore_unknown_options": True,
-    },
-)
-def get_bakebook(
-    chdir: str = chdir_option,
-    file_name: str = file_name_option,
-    bakebook_name: str = bakebook_name_option,
-):
-    try:
-        return resolve_bakebook(file_name=file_name, bakebook_name=bakebook_name, chdir=chdir)
-    except BakebookError as e:
-        # Print error with context about what values were used
-        context_parts = []
-        context_parts.append(f"chdir={chdir!r}")
-        context_parts.append(f"file_name={file_name!r}")
-        context_parts.append(f"bakebook_name={bakebook_name!r}")
-
-        typer.secho("⚠️  ", fg="yellow", err=True, nl=False)
-        typer.secho(str(e), fg="yellow", bold=True, err=True)
-        if context_parts:
-            typer.secho(f"({', '.join(context_parts)})", fg="yellow", err=True)
-        return None
-
-
-def try_get_local_bake_app() -> typer.Typer | None:
-    args = get_bakebook_args()
-
-    for registered_command in bake_app.registered_commands:
-        if registered_command.name == GET_BAKEBOOK:
-            command = get_command_from_info(
-                registered_command,
-                pretty_exceptions_short=bake_app.pretty_exceptions_short,
-                rich_markup_mode=bake_app.rich_markup_mode,
-            )
-            with command.make_context(info_name=GET_BAKEBOOK, args=args) as ctx:
-                bakebook = command.invoke(ctx)
-                if bakebook is not None:
-                    local_bake_app.add_typer(bakebook)
-                    return local_bake_app
-                return None
-
-
-def main():
-    local_bake_app = try_get_local_bake_app()
-    if local_bake_app is None:
-        bake_app()
-    else:
-        local_bake_app()

bakefile/cli/bake/resolve_bakebook.py

@@ -1,103 +0,0 @@
-import importlib.util
-import os
-import pathlib
-import sys
-import types
-from typing import Any, TypeVar
-
-import typer
-
-from bakefile.exceptions import BakebookError
-
-T = TypeVar("T")
-
-
-def change_directory(path: str) -> None:
-    if not path or not path.strip():
-        raise BakebookError("Directory path cannot be empty")
-    dir_path = pathlib.Path(path)
-    if not dir_path.exists():
-        raise BakebookError(f"Directory not found: {path}")
-    if not dir_path.is_dir():
-        raise BakebookError(f"Not a directory: {path}")
-    os.chdir(dir_path)
-
-
-def validate_file_name(file_name: str) -> bool:
-    if "/" in file_name or "\\" in file_name:
-        raise BakebookError(f"File name must not contain path separators: {file_name}")
-    if not file_name.endswith(".py"):
-        raise BakebookError(f"File name must end with .py: {file_name}")
-    return True
-
-
-def resolve_file_path(file_name: str) -> pathlib.Path:
-    path = pathlib.Path.cwd() / file_name
-    if not path.exists():
-        raise BakebookError(f"File not found: {file_name}")
-    return path
-
-
-def load_module(path: pathlib.Path) -> types.ModuleType:
-    module_name = "bakefile"
-    spec = importlib.util.spec_from_file_location(module_name, path)
-    if spec is None or spec.loader is None:
-        raise BakebookError(f"Failed to load: {path}")
-
-    module: types.ModuleType = importlib.util.module_from_spec(spec)
-    sys.modules[module_name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-# Update this is lowest python support is >= 3.12
-# Use a generic type parameter for this function instead of a "TypeVar".
-def validate_bakebook(bakebook: Any, bakebook_name: str, expected_type: type[T]) -> T:
-    """Validate bakebook is of expected type and return it.
-
-    Parameters
-    ----------
-    bakebook : Any
-        The bakebook object to validate
-    bakebook_name : str
-        Name of the bakebook variable (for error messages)
-    expected_type : type[T]
-        The expected type (e.g., typer.Typer)
-
-    Returns
-    -------
-    T
-        The validated bakebook
-
-    Raises
-    ------
-    BakebookError
-        If bakebook is not of expected type
-    """
-    if not isinstance(bakebook, expected_type):
-        raise BakebookError(
-            f"Bakebook '{bakebook_name}' must be a {expected_type.__name__}, "
-            f"got {type(bakebook).__name__}"
-        )
-
-    return bakebook
-
-
-def get_bakebook(module: types.ModuleType, bakebook_name: str, path: pathlib.Path) -> typer.Typer:
-    if not hasattr(module, bakebook_name):
-        raise BakebookError(f"No '{bakebook_name}' found in {path}")
-    bakebook = getattr(module, bakebook_name)
-    bakebook = validate_bakebook(
-        bakebook=bakebook, bakebook_name=bakebook_name, expected_type=typer.Typer
-    )
-    return bakebook
-
-
-def resolve_bakebook(file_name: str, bakebook_name: str, chdir: str | None = None) -> typer.Typer:
-    if chdir:
-        change_directory(chdir)
-
-    validate_file_name(file_name)
-    path = resolve_file_path(file_name)
-    module = load_module(path)
-    return get_bakebook(module=module, bakebook_name=bakebook_name, path=path)

bakefile/cli/bake/utils.py

@@ -1,25 +0,0 @@
-import os
-import sys
-
-import click
-
-
-def get_bakebook_args(
-    args: list[str] | None = None,
-    windows_expand_args: bool = True,
-) -> list[str]:
-    # source from https://github.com/fastapi/typer/blob/b7f39eaad60141988f5d9a58df72c44d6128cd53/typer/core.py#L175-L185
-
-    if args is None:
-        args = sys.argv[1:]
-
-        # Covered in Click tests
-        if os.name == "nt" and windows_expand_args:  # pragma: no cover
-            args = click.utils._expand_args(args)
-    else:
-        args = list(args)
-
-    non_get_bakebook_args = ["--help", "--version"]
-
-    args = [arg for arg in args if arg not in non_get_bakebook_args]
-    return args

bakefile/cli/bakefile.py

@@ -1,19 +0,0 @@
-import typer
-
-from bakefile.cli.utils.version import version_callback
-
-app = typer.Typer(add_completion=True)
-
-
-@app.command()
-def main(
-    version: bool = typer.Option(
-        False,
-        "--version",
-        help="Show version and exit",
-        callback=version_callback,
-        is_eager=True,
-    ),
-) -> None:
-    _ = version
-    typer.echo("hello world")

bakefile/cli/utils/version.py

@@ -1,9 +0,0 @@
-import typer
-
-from bakefile import __version__
-
-
-def version_callback(value: bool) -> None:
-    if value:
-        typer.echo(__version__)
-        raise typer.Exit()