bakefile 0.0.10__py3-none-any.whl → 0.0.12__py3-none-any.whl

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,
@@ -62,19 +84,11 @@ class BaseSpace(Bakebook):
             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 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")

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,7 @@
 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
@@ -87,3 +88,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