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

bakelib/refreshable_cache/cache.py

@@ -0,0 +1,250 @@
+import contextlib
+import functools
+import inspect
+import logging
+import time
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, ParamSpec, TypeVar
+
+import keyring as kr
+from keyring.errors import PasswordDeleteError
+from pydantic import BaseModel, TypeAdapter
+from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_none
+
+from bakelib.refreshable_cache.exceptions import RefreshNeededError
+
+if TYPE_CHECKING:
+    from tenacity.stop import StopBaseT
+    from tenacity.wait import WaitBaseT
+
+
+logger = logging.getLogger(__name__)
+
+P = ParamSpec("P")
+F = TypeVar("F", bound=Callable[..., Any])
+T = TypeVar("T")
+CachedT = TypeVar("CachedT", covariant=True)
+
+
+class CacheEntry(BaseModel, Generic[CachedT]):
+    """Cache entry containing the cached value and timestamp."""
+
+    value: CachedT
+    timestamp: float
+
+
+DEFAULT_NAMESPACE = "bakelib.refreshable_cache"
+
+
+class RefreshableCache(ABC, Generic[CachedT]):
+    """Cache that can be refreshed when values expire or become invalid."""
+
+    RefreshNeededError: type[RefreshNeededError] = RefreshNeededError
+
+    def __init__(
+        self,
+        key: str,
+        fetch_fn: Callable[[], CachedT],
+        ttl: float | None = None,
+        namespace: str | None = None,
+        stop: "StopBaseT | None" = None,
+        wait: "WaitBaseT | None" = None,
+        cached_type: Any = None,
+    ) -> None:
+        self._key = key
+        self._fetch_fn = fetch_fn
+        self._ttl = ttl
+        self._namespace = namespace if namespace is not None else DEFAULT_NAMESPACE
+        self._stop = stop if stop is not None else stop_after_attempt(2)
+        self._wait = wait if wait is not None else wait_none()
+
+        # Determine cached type: explicit cached_type or infer from fetch_fn
+        if cached_type is not None:
+            return_type = cached_type
+        else:
+            return_type = inspect.signature(fetch_fn).return_annotation
+            if return_type is inspect.Parameter.empty:
+                msg = "fetch_fn must have a return type annotation or cached_type must be provided"
+                raise TypeError(msg)
+
+        self._adapter = TypeAdapter(CacheEntry[return_type])
+
+    def _get_full_key(self) -> str:
+        return f"{self._namespace}:{self._key}"
+
+    def _serialize_entry(self, value: CachedT) -> bytes:
+        entry = CacheEntry(value=value, timestamp=time.time())
+        return self._adapter.dump_json(entry)
+
+    def _deserialize_entry(self, data: bytes) -> CacheEntry[CachedT]:
+        return self._adapter.validate_json(data)
+
+    def _is_expired(self, timestamp: float) -> bool:
+        if self._ttl is None:
+            return False
+        return time.time() - timestamp > self._ttl
+
+    def get_value(self) -> CachedT:
+        cached = self._get_entry()
+        if cached is None:
+            logger.debug(f"Cache miss for key '{self._key}', fetching value")
+            return self._refresh()
+        if self._is_expired(cached.timestamp):
+            logger.debug(f"Cache expired for key '{self._key}', fetching fresh value")
+            return self._refresh()
+        logger.debug(f"Cache hit for key '{self._key}'")
+        return cached.value
+
+    def _refresh(self) -> CachedT:
+        logger.debug(f"Refreshing value for key '{self._key}'")
+        value = self._fetch_fn()
+        self.set(value)
+        return value
+
+    def catch_refresh(self, func: Callable[P, T]) -> Callable[P, T]:
+        @functools.wraps(func)
+        @retry(
+            stop=self._stop,
+            wait=self._wait,
+            retry=retry_if_exception_type(self.RefreshNeededError),
+            reraise=True,
+        )
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            try:
+                return func(*args, **kwargs)
+            except self.RefreshNeededError:
+                self.delete()
+                raise
+
+        return wrapper
+
+    @abstractmethod
+    def _get_entry(self) -> CacheEntry[CachedT] | None: ...
+
+    @abstractmethod
+    def set(self, value: CachedT) -> None: ...
+
+    @abstractmethod
+    def delete(self) -> None: ...
+
+
+class KeyringCache(RefreshableCache[CachedT]):
+    """Cache using system keyring for persistent storage."""
+
+    def _get_entry(self) -> CacheEntry[CachedT] | None:
+        data = kr.get_password(self._namespace, self._key)
+        if data is None:
+            return None
+        return self._deserialize_entry(data.encode())
+
+    def set(self, value: CachedT) -> None:
+        data = self._serialize_entry(value).decode()
+        kr.set_password(self._namespace, self._key, data)
+
+    def delete(self) -> None:
+        with contextlib.suppress(PasswordDeleteError):
+            kr.delete_password(self._namespace, self._key)
+
+
+class MemoryCache(RefreshableCache[CachedT]):
+    """In-memory cache for ephemeral storage."""
+
+    _storage: ClassVar[dict[str, CacheEntry[CachedT]]] = {}
+
+    def _get_entry(self) -> CacheEntry[CachedT] | None:
+        entry = self._storage.get(self._get_full_key())
+        if entry is None:
+            return None
+        return entry
+
+    def set(self, value: CachedT) -> None:
+        self._storage[self._get_full_key()] = CacheEntry(value=value, timestamp=time.time())
+
+    def delete(self) -> None:
+        self._storage.pop(self._get_full_key(), None)
+
+
+class NullCache(RefreshableCache[CachedT]):
+    """Cache that doesn't cache anything (Null Object pattern).
+
+    Useful as a final fallback when you want to explicitly disable caching.
+    Reads always return None (triggering fetch), writes/deletes do nothing.
+    """
+
+    def _get_entry(self) -> CacheEntry[CachedT] | None:
+        return None
+
+    def set(self, value: CachedT) -> None:
+        pass
+
+    def delete(self) -> None:
+        pass
+
+
+class ChainedCache(RefreshableCache[CachedT]):
+    """Tries multiple backends in order.
+
+    Reads from the first backend that has data.
+    Writes to all backends (stops on first success).
+    """
+
+    _backends: list[RefreshableCache[CachedT]]
+
+    def __init__(
+        self,
+        backends: list[type[RefreshableCache[CachedT]]],
+        key: str,
+        fetch_fn: Callable[[], CachedT],
+        ttl: float | None = None,
+        namespace: str | None = None,
+        stop: "StopBaseT | None" = None,
+        wait: "WaitBaseT | None" = None,
+        cached_type: Any = None,
+    ) -> None:
+        super().__init__(
+            key=key,
+            fetch_fn=fetch_fn,
+            ttl=ttl,
+            namespace=namespace,
+            stop=stop,
+            wait=wait,
+            cached_type=cached_type,
+        )
+        self._backends = [
+            backend(
+                key=key,
+                fetch_fn=fetch_fn,
+                ttl=ttl,
+                namespace=namespace,
+                stop=stop,
+                wait=wait,
+                cached_type=cached_type,
+            )
+            for backend in backends
+        ]
+
+    def _get_entry(self) -> CacheEntry[CachedT] | None:
+        for backend in self._backends:
+            try:
+                entry = backend._get_entry()
+                if entry is not None:
+                    return entry
+            except Exception:
+                continue
+        return None
+
+    def set(self, value: CachedT) -> None:
+        for backend in self._backends:
+            try:
+                backend.set(value)
+                return
+            except Exception:
+                continue
+
+    def delete(self) -> None:
+        for backend in self._backends:
+            try:
+                backend.delete()
+            except Exception:
+                continue

bakelib/refreshable_cache/exceptions.py

@@ -0,0 +1,2 @@
+class RefreshNeededError(Exception):
+    """Raised when a cached value needs to be refreshed."""

bakelib/space/base.py

@@ -45,6 +45,28 @@ class BaseSpace(Bakebook):
     def test_all(self, ctx: Context) -> None:
         self._no_implementation(ctx)
 
+    def _clean(
+        self,
+        ctx: Context,
+        exclude_patterns: list[str] | None,
+        default_excludes: bool,
+        default_exclude_patterns: set[str],
+    ):
+        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 default_excludes:
+            exclude_patterns |= default_exclude_patterns
+
+        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 gitignored files with optional exclusions")
     def clean(
         self,
@@ -57,28 +79,16 @@ class BaseSpace(Bakebook):
                 help="Patterns to exclude",
             ),
         ] = None,
-        use_default_excludes: Annotated[
+        default_excludes: Annotated[
             bool,
-            typer.Option(
-                "--no-default-excludes",
-                help="Do not apply default exclude patterns",
-                is_flag=True,
-            ),
-        ] = False,
+            typer.Option(help="Apply default exclude patterns (.env, .cache)"),
+        ] = True,
     ) -> 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,
+        self._clean(
+            ctx=ctx,
             exclude_patterns=exclude_patterns,
-            dry_run=ctx.dry_run,
+            default_excludes=default_excludes,
+            default_exclude_patterns={".env", ".cache"},
         )
 
     @command(help="Clean all gitignored files")
@@ -175,7 +185,6 @@ class BaseSpace(Bakebook):
                 "--skip-test",
                 "-s",
                 help="Skip running tests",
-                is_flag=True,
             ),
         ] = False,
     ) -> None:

bakelib/space/lib.py

@@ -0,0 +1,161 @@
+import subprocess
+from abc import abstractmethod
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Annotated
+
+import typer
+from pydantic import SecretStr
+from tenacity import stop_after_attempt
+
+from bake import Context, command, console
+from bake.ui.logger import strip_ansi
+from bakelib.refreshable_cache import ChainedCache, KeyringCache, NullCache
+
+from .base import BaseSpace, ToolInfo
+from .utils import CARGO_BIN, PlatformType, get_expected_paths, setup_rustup, setup_zerv
+
+
+@dataclass
+class PublishResult:
+    result: subprocess.CompletedProcess[str] | None
+    is_dry_run: bool
+    is_auth_failed: bool
+
+
+class BaseLibSpace(BaseSpace):
+    bake_publish_token: SecretStr | None = None
+    _dummy_publish_token: str = "dummy-token-for-dry-run"
+
+    def setup_tools(self, ctx: Context, platform: PlatformType) -> None:
+        _ = platform
+        super().setup_tools(ctx, platform=platform)
+        setup_rustup(ctx)
+        setup_zerv(ctx)
+
+    @abstractmethod
+    def _get_publish_token_from_remote(self, registry: str) -> str | None: ...
+
+    @abstractmethod
+    def package_name(self, ctx: Context) -> str: ...
+
+    @abstractmethod
+    def _build_for_publish(self, ctx: Context): ...
+
+    @abstractmethod
+    def _publish_with_token(
+        self, ctx: Context, token: str | None, registry: str
+    ) -> PublishResult: ...
+
+    def _get_cached_publish_token(
+        self, ctx: Context, token: str | None, registry: str
+    ) -> ChainedCache[str | None]:
+        token_from_local = self._get_token_from_local(token)
+        key = f"publish-token-{registry}"
+        namespace = self.package_name(ctx)
+
+        def get_publish_token() -> str | None:
+            return token_from_local or self._get_publish_token_from_remote(registry)
+
+        stop = stop_after_attempt(1) if token_from_local else None
+
+        cached_publish_token = ChainedCache(
+            backends=[KeyringCache, NullCache],
+            namespace=namespace,
+            key=key,
+            fetch_fn=get_publish_token,
+            stop=stop,
+        )
+
+        if token_from_local is not None:
+            cached_publish_token.set(token_from_local)
+
+        return cached_publish_token
+
+    def _get_token_from_local(self, token: str | None) -> str | None:
+        if token:
+            return token
+
+        if self.bake_publish_token:
+            return self.bake_publish_token.get_secret_value()
+
+        return None
+
+    @contextmanager
+    @abstractmethod
+    def _version_bump_context(self, _ctx: Context, _version: str): ...
+
+    @abstractmethod
+    def _pre_publish_cleanup(self, _ctx: Context): ...
+
+    @property
+    def _version_schema(self) -> str | None:
+        return None
+
+    def _is_auth_failure(self, result: subprocess.CompletedProcess[str]) -> bool:
+        return result.returncode != 0
+
+    def _determine_version(self, ctx: Context, version: str | None) -> str:
+        return version if version else self.zerv_versioning(ctx, schema=self._version_schema)
+
+    @command(help="Build and publish the package")
+    def publish(
+        self,
+        ctx: Context,
+        registry: Annotated[str, typer.Option(help="Publish registry")] = "default",
+        token: Annotated[str | None, typer.Option(help="Publish token")] = None,
+        version: Annotated[str | None, typer.Option(help="Version to publish")] = None,
+    ):
+        cached_publish_token = self._get_cached_publish_token(
+            ctx=ctx, token=token, registry=registry
+        )
+        version = self._determine_version(ctx, version)
+
+        self._pre_publish_cleanup(ctx)
+
+        with self._version_bump_context(ctx, version):
+            self._build_for_publish(ctx)
+            publish_result = self._execute_publish(
+                ctx=ctx, cached_publish_token=cached_publish_token, registry=registry
+            )
+
+        self._handle_publish_result(ctx, publish_result=publish_result)
+
+    def _execute_publish(
+        self, ctx: Context, cached_publish_token: ChainedCache[str | None], registry: str
+    ) -> PublishResult:
+        @cached_publish_token.catch_refresh
+        def _publish() -> PublishResult:
+            token_value = cached_publish_token.get_value()
+            publish_result = self._publish_with_token(ctx=ctx, token=token_value, registry=registry)
+
+            if publish_result.result is not None and self._is_auth_failure(publish_result.result):
+                raise cached_publish_token.RefreshNeededError
+
+            return publish_result
+
+        try:
+            return _publish()
+        except cached_publish_token.RefreshNeededError:
+            return PublishResult(result=None, is_dry_run=False, is_auth_failed=True)
+
+    def _handle_publish_result(self, ctx: Context, publish_result: PublishResult) -> None:
+        if publish_result.is_auth_failed:
+            console.error("Authentication failed. Please check your publish token.")
+            raise typer.Exit(1)
+
+        if publish_result.is_dry_run and not ctx.dry_run:
+            console.warning(
+                "This was a dry-run. To actually publish, "
+                "set the BAKE_PUBLISH_TOKEN environment variable"
+            )
+
+    def zerv_versioning(self, ctx: Context, *, schema: str | None = None) -> str:
+        schema_flag = f"--schema {schema}" if schema else ""
+        result = ctx.run(f"zerv flow {schema_flag}", dry_run=False)
+        return strip_ansi(result.stdout.strip())
+
+    def _get_tools(self) -> dict[str, ToolInfo]:
+        tools = super()._get_tools()
+        tools["zerv"] = ToolInfo(expected_paths=get_expected_paths("zerv", {CARGO_BIN}))
+        return tools

bakelib/space/python.py

@@ -1,6 +1,8 @@
+import os
 from pathlib import Path
 
 from bake import Context, params
+from bake.ui.logger import strip_ansi
 
 from .base import BaseSpace, ToolInfo
 from .utils import VENV_BIN, get_expected_paths
@@ -14,6 +16,10 @@ def _get_python_version() -> str | None:
 
 
 class PythonSpace(BaseSpace):
+    def __init__(self) -> None:
+        super().__init__()
+        os.environ["UV_NO_PROGRESS"] = "true"
+
     def _get_tools(self) -> dict[str, ToolInfo]:
         tools = super()._get_tools()
         tools["python"] = ToolInfo(
@@ -87,3 +93,14 @@ class PythonSpace(BaseSpace):
         super().update(ctx=ctx)
         ctx.run("uv lock --upgrade")
         ctx.run("uv sync --all-extras --all-groups")
+
+    def _uv_version(self, ctx: Context) -> tuple[str, str]:
+        result = ctx.run("uv version", stream=False, dry_run=False, echo=False)
+        package_name, original_version = strip_ansi(result.stdout.strip()).split()
+        return package_name, original_version
+
+    def package_name(self, ctx: Context) -> str:
+        return self._uv_version(ctx)[0]
+
+    def current_version(self, ctx: Context) -> str:
+        return self._uv_version(ctx)[1]

bakelib/space/python_lib.py

@@ -0,0 +1,77 @@
+import shutil
+import subprocess
+from contextlib import contextmanager
+from typing import Annotated, Literal, cast, get_args
+
+import typer
+
+from bake import Context
+
+from .lib import BaseLibSpace, PublishResult
+from .python import PythonSpace
+
+PublishIndex = Literal["testpypi", "pypi"]
+
+
+class PythonLibSpace(PythonSpace, BaseLibSpace):
+    @property
+    def _version_schema(self) -> str | None:
+        return "standard-base-prerelease-post-dev"
+
+    def _registry_to_index(self, registry: str) -> PublishIndex:
+        valid_indices = get_args(PublishIndex)
+        if registry not in valid_indices:
+            raise ValueError(f"Invalid registry: {registry!r}. Expected one of {valid_indices}.")
+        return cast(PublishIndex, registry)
+
+    def _get_publish_token_from_remote(self, registry: str) -> str | None:
+        index = self._registry_to_index(registry)
+        _ = index
+        return None
+
+    def _build_for_publish(self, ctx: Context):
+        ctx.run("uv build")
+
+    def _publish_with_token(self, ctx: Context, token: str | None, registry: str) -> PublishResult:
+        index = self._registry_to_index(registry)
+        index_flag = f"--index {index} " if index == "testpypi" else ""
+        dry_run_flag = "" if token is not None else "--dry-run "
+        is_dry_run = token is None
+
+        env: dict[str, str] = {
+            "UV_PUBLISH_TOKEN": token if token is not None else self._dummy_publish_token
+        }
+
+        result = ctx.run(
+            f"uv publish {dry_run_flag}{index_flag}",
+            stream=True,
+            env=env,
+            check=False,
+        )
+
+        return PublishResult(result=result, is_dry_run=is_dry_run, is_auth_failed=False)
+
+    def _is_auth_failure(self, result: subprocess.CompletedProcess[str]) -> bool:
+        auth_error_message = "403 Invalid or non-existent authentication information"
+        return result.returncode != 0 and auth_error_message in result.stderr
+
+    @contextmanager
+    def _version_bump_context(self, ctx: Context, version: str):
+        original_version = self.current_version(ctx)
+        ctx.run(f"uv version {version}")
+        try:
+            yield
+        finally:
+            ctx.run(f"uv version {original_version}")
+
+    def _pre_publish_cleanup(self, _ctx: Context):
+        shutil.rmtree("dist", ignore_errors=True)
+
+    def publish(
+        self,
+        ctx: Context,
+        index: Annotated[PublishIndex, typer.Option(help="Publish index")] = "testpypi",
+        token: Annotated[str | None, typer.Option(help="Publish token")] = None,
+        version: Annotated[str | None, typer.Option(help="Version to publish")] = None,
+    ):
+        return super().publish(ctx=ctx, registry=index, token=token, version=version)

bakelib/space/utils.py

@@ -52,6 +52,15 @@ def setup_uv(ctx: Context) -> None:
     ctx.run("uv tool update-shell")
 
 
+def setup_rustup(ctx: Context) -> None:
+    ctx.run("brew install rustup")
+    ctx.run("rustup update")
+
+
+def setup_zerv(ctx: Context) -> None:
+    ctx.run("cargo install zerv")
+
+
 def setup_bun(ctx: Context) -> None:
     ctx.run("brew install oven-sh/bun/bun")
 
@@ -62,6 +71,7 @@ def setup_uv_tool(ctx: Context) -> None:
 
 
 HOMWBREW_BIN = Path("/opt/homebrew/bin")
+CARGO_BIN = Path.home() / ".cargo" / "bin"
 LOCAL_BIN = Path.home() / ".local" / "bin"
 VENV_BIN = Path.cwd() / ".venv" / "bin"
 

bake/cli/common/callback.py

@@ -1,13 +0,0 @@
-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)

bake/utils/env.py

@@ -1,10 +0,0 @@
-import os
-
-ENV_NO_COLOR = "NO_COLOR"
-
-_BAKE_REINVOKED = "_BAKE_REINVOKED"
-
-
-def should_use_colors() -> bool:
-    value = os.environ.get(ENV_NO_COLOR)
-    return value == "" or value is None