furu 0.0.1__tar.gz → 0.0.2__tar.gz

{furu-0.0.1 → furu-0.0.2}/PKG-INFO

@@ -1,19 +1,20 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: furu
-Version: 0.0.1
+Version: 0.0.2
 Summary: Cacheable, nested pipelines for Python. Define computations as configs; furu handles caching, state tracking, and result reuse across runs.
+Author: Herman Brunborg
 Author-email: Herman Brunborg <herman@brunborg.com>
-Requires-Python: >=3.12
 Requires-Dist: chz>=0.4.0
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rich>=14.2.0
 Requires-Dist: submitit>=1.5.3
+Requires-Dist: fastapi>=0.109.0 ; extra == 'dashboard'
+Requires-Dist: uvicorn[standard]>=0.27.0 ; extra == 'dashboard'
+Requires-Dist: typer>=0.9.0 ; extra == 'dashboard'
+Requires-Python: >=3.12
 Provides-Extra: dashboard
-Requires-Dist: fastapi>=0.109.0; extra == 'dashboard'
-Requires-Dist: typer>=0.9.0; extra == 'dashboard'
-Requires-Dist: uvicorn[standard]>=0.27.0; extra == 'dashboard'
 Description-Content-Type: text/markdown
 
 # furu
@@ -132,20 +133,25 @@ class TrainTextModel(furu.Furu[str]):
 
 ### Storage Structure
 
+Furu uses two roots: `FURU_PATH` for `data/` + `raw/`, and
+`FURU_VERSION_CONTROLLED_PATH` for `artifacts/`. Defaults:
+
+```
+FURU_PATH=<project>/furu-data
+FURU_VERSION_CONTROLLED_PATH=<project>/furu-data/artifacts
+```
+
+`<project>` is the nearest directory containing `pyproject.toml` (falling back to
+the git root). This means you can move `FURU_PATH` without relocating artifacts.
+
 ```
 $FURU_PATH/
-├── data/                         # Default storage (version_controlled=False)
-│   └── <module>/<Class>/
-│       └── <hash>/
-│           ├── .furu/
-│           │   ├── metadata.json # Config, git info, environment
-│           │   ├── state.json    # Status and timestamps
-│           │   ├── furu.log    # Captured logs
-│           │   └── SUCCESS.json  # Marker file
-│           └── <your outputs>    # Files from _create()
-├── git/                          # For version_controlled=True
-│   └── <same structure>
-└── raw/                          # Shared directory for large files
+├── data/                         # version_controlled=False
+│   └── <module>/<Class>/<hash>/
+└── raw/
+
+$FURU_VERSION_CONTROLLED_PATH/    # version_controlled=True
+└── <module>/<Class>/<hash>/
 ```
 
 ## Features
@@ -259,10 +265,17 @@ For artifacts that should be stored separately (e.g., checked into git):
 
 ```python
 class VersionedConfig(furu.Furu[dict], version_controlled=True):
-    # Stored under $FURU_PATH/git/ instead of $FURU_PATH/data/
+    # Stored under $FURU_VERSION_CONTROLLED_PATH
+    # Default: <project>/furu-data/artifacts
     ...
 ```
 
+`<project>` is the nearest directory containing `pyproject.toml`, or the git root
+if `pyproject.toml` is missing.
+
+It is typical to keep `furu-data/data/` and `furu-data/raw/` in `.gitignore` while
+committing `furu-data/artifacts/`.
+
 ## Logging
 
 Furu installs stdlib `logging` handlers that capture logs to per-artifact files.
@@ -397,9 +410,11 @@ The `/api/experiments` endpoint supports:
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `FURU_PATH` | `./data-furu/` | Base storage directory |
+| `FURU_PATH` | `<project>/furu-data` | Base storage directory for non-versioned artifacts |
+| `FURU_VERSION_CONTROLLED_PATH` | `<project>/furu-data/artifacts` | Override version-controlled storage root |
 | `FURU_LOG_LEVEL` | `INFO` | Console verbosity (`DEBUG`, `INFO`, `WARNING`, `ERROR`) |
 | `FURU_IGNORE_DIFF` | `false` | Skip embedding git diff in metadata |
+| `FURU_ALWAYS_RERUN` | `""` | Comma-separated class qualnames to always rerun (use `ALL` to bypass cache globally; cannot combine with other entries; entries must be importable) |
 | `FURU_POLL_INTERVAL_SECS` | `10` | Polling interval for queued/running jobs |
 | `FURU_WAIT_LOG_EVERY_SECS` | `10` | Interval between "waiting" log messages |
 | `FURU_STALE_AFTER_SECS` | `1800` | Consider running jobs stale after this duration |

{furu-0.0.1 → furu-0.0.2}/README.md

@@ -114,20 +114,25 @@ class TrainTextModel(furu.Furu[str]):
 
 ### Storage Structure
 
+Furu uses two roots: `FURU_PATH` for `data/` + `raw/`, and
+`FURU_VERSION_CONTROLLED_PATH` for `artifacts/`. Defaults:
+
+```
+FURU_PATH=<project>/furu-data
+FURU_VERSION_CONTROLLED_PATH=<project>/furu-data/artifacts
+```
+
+`<project>` is the nearest directory containing `pyproject.toml` (falling back to
+the git root). This means you can move `FURU_PATH` without relocating artifacts.
+
 ```
 $FURU_PATH/
-├── data/                         # Default storage (version_controlled=False)
-│   └── <module>/<Class>/
-│       └── <hash>/
-│           ├── .furu/
-│           │   ├── metadata.json # Config, git info, environment
-│           │   ├── state.json    # Status and timestamps
-│           │   ├── furu.log    # Captured logs
-│           │   └── SUCCESS.json  # Marker file
-│           └── <your outputs>    # Files from _create()
-├── git/                          # For version_controlled=True
-│   └── <same structure>
-└── raw/                          # Shared directory for large files
+├── data/                         # version_controlled=False
+│   └── <module>/<Class>/<hash>/
+└── raw/
+
+$FURU_VERSION_CONTROLLED_PATH/    # version_controlled=True
+└── <module>/<Class>/<hash>/
 ```
 
 ## Features
@@ -241,10 +246,17 @@ For artifacts that should be stored separately (e.g., checked into git):
 
 ```python
 class VersionedConfig(furu.Furu[dict], version_controlled=True):
-    # Stored under $FURU_PATH/git/ instead of $FURU_PATH/data/
+    # Stored under $FURU_VERSION_CONTROLLED_PATH
+    # Default: <project>/furu-data/artifacts
     ...
 ```
 
+`<project>` is the nearest directory containing `pyproject.toml`, or the git root
+if `pyproject.toml` is missing.
+
+It is typical to keep `furu-data/data/` and `furu-data/raw/` in `.gitignore` while
+committing `furu-data/artifacts/`.
+
 ## Logging
 
 Furu installs stdlib `logging` handlers that capture logs to per-artifact files.
@@ -379,9 +391,11 @@ The `/api/experiments` endpoint supports:
 
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `FURU_PATH` | `./data-furu/` | Base storage directory |
+| `FURU_PATH` | `<project>/furu-data` | Base storage directory for non-versioned artifacts |
+| `FURU_VERSION_CONTROLLED_PATH` | `<project>/furu-data/artifacts` | Override version-controlled storage root |
 | `FURU_LOG_LEVEL` | `INFO` | Console verbosity (`DEBUG`, `INFO`, `WARNING`, `ERROR`) |
 | `FURU_IGNORE_DIFF` | `false` | Skip embedding git diff in metadata |
+| `FURU_ALWAYS_RERUN` | `""` | Comma-separated class qualnames to always rerun (use `ALL` to bypass cache globally; cannot combine with other entries; entries must be importable) |
 | `FURU_POLL_INTERVAL_SECS` | `10` | Polling interval for queued/running jobs |
 | `FURU_WAIT_LOG_EVERY_SECS` | `10` | Interval between "waiting" log messages |
 | `FURU_STALE_AFTER_SECS` | `1800` | Consider running jobs stale after this duration |

{furu-0.0.1 → furu-0.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "furu"
-version = "0.0.1"
+version = "0.0.2"
 description = "Cacheable, nested pipelines for Python. Define computations as configs; furu handles caching, state tracking, and result reuse across runs."
 readme = "README.md"
 authors = [
@@ -42,14 +42,8 @@ test = [
 ]
 
 [build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build]
-artifacts = ["src/furu/dashboard/frontend/dist/**/*"]
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/furu"]
+requires = ["uv_build>=0.9.26,<0.10.0"]
+build-backend = "uv_build"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

furu-0.0.2/src/furu/config.py

@@ -0,0 +1,172 @@
+import os
+from importlib import import_module
+from pathlib import Path
+
+
+class FuruConfig:
+    """Central configuration for Furu behavior."""
+
+    DEFAULT_ROOT_DIR = Path("furu-data")
+    VERSION_CONTROLLED_SUBDIR = DEFAULT_ROOT_DIR / "artifacts"
+
+    def __init__(self):
+        def _get_base_root() -> Path:
+            env = os.getenv("FURU_PATH")
+            if env:
+                return Path(env).expanduser().resolve()
+            project_root = self._find_project_root(fallback_to_cwd=True)
+            return (project_root / self.DEFAULT_ROOT_DIR).resolve()
+
+        self.base_root = _get_base_root()
+        self.version_controlled_root_override = self._get_version_controlled_override()
+        self.poll_interval = float(os.getenv("FURU_POLL_INTERVAL_SECS", "10"))
+        self.wait_log_every_sec = float(os.getenv("FURU_WAIT_LOG_EVERY_SECS", "10"))
+        self.stale_timeout = float(os.getenv("FURU_STALE_AFTER_SECS", str(30 * 60)))
+        self.lease_duration_sec = float(os.getenv("FURU_LEASE_SECS", "120"))
+        hb = os.getenv("FURU_HEARTBEAT_SECS")
+        self.heartbeat_interval_sec = (
+            float(hb) if hb is not None else max(1.0, self.lease_duration_sec / 3.0)
+        )
+        self.max_requeues = int(os.getenv("FURU_PREEMPT_MAX", "5"))
+        self.ignore_git_diff = os.getenv("FURU_IGNORE_DIFF", "0").lower() in {
+            "1",
+            "true",
+            "yes",
+        }
+        self.require_git = os.getenv("FURU_REQUIRE_GIT", "1").lower() in {
+            "1",
+            "true",
+            "yes",
+        }
+        self.require_git_remote = os.getenv("FURU_REQUIRE_GIT_REMOTE", "1").lower() in {
+            "1",
+            "true",
+            "yes",
+        }
+        always_rerun_items = {
+            item.strip()
+            for item in os.getenv("FURU_ALWAYS_RERUN", "").split(",")
+            if item.strip()
+        }
+        all_entries = {item for item in always_rerun_items if item.lower() == "all"}
+        if all_entries and len(always_rerun_items) > len(all_entries):
+            raise ValueError(
+                "FURU_ALWAYS_RERUN cannot combine 'ALL' with specific entries"
+            )
+        self.always_rerun_all = bool(all_entries)
+        if self.always_rerun_all:
+            always_rerun_items = {
+                item for item in always_rerun_items if item.lower() != "all"
+            }
+        self._require_namespaces_exist(always_rerun_items)
+        self.always_rerun = always_rerun_items
+        self.cancelled_is_preempted = os.getenv(
+            "FURU_CANCELLED_IS_PREEMPTED", "false"
+        ).lower() in {"1", "true", "yes"}
+
+        # Parse FURU_CACHE_METADATA: "never", "forever", or duration like "5m", "1h"
+        # Default: "5m" (5 minutes) - balances performance with freshness
+        self.cache_metadata_ttl_sec: float | None = self._parse_cache_duration(
+            os.getenv("FURU_CACHE_METADATA", "5m")
+        )
+
+    @staticmethod
+    def _parse_cache_duration(value: str) -> float | None:
+        """Parse cache duration string into seconds. Returns None for 'never', float('inf') for 'forever'."""
+        value = value.strip().lower()
+        if value in {"never", "0", "false", "no"}:
+            return None  # No caching
+        if value in {"forever", "inf", "true", "yes", "1"}:
+            return float("inf")  # Cache forever
+
+        # Parse duration like "5m", "1h", "30s"
+        import re
+
+        match = re.match(r"^(\d+(?:\.\d+)?)\s*([smh]?)$", value)
+        if not match:
+            raise ValueError(
+                f"Invalid FURU_CACHE_METADATA value: {value!r}. "
+                "Use 'never', 'forever', or duration like '5m', '1h', '30s'"
+            )
+
+        num = float(match.group(1))
+        unit = match.group(2) or "s"
+        multipliers = {"s": 1, "m": 60, "h": 3600}
+        return num * multipliers[unit]
+
+    def get_root(self, version_controlled: bool = False) -> Path:
+        """Get root directory for storage (version_controlled uses its own root)."""
+        if version_controlled:
+            if self.version_controlled_root_override is not None:
+                return self.version_controlled_root_override
+            return self._resolve_version_controlled_root()
+        return self.base_root / "data"
+
+    @classmethod
+    def _get_version_controlled_override(cls) -> Path | None:
+        env = os.getenv("FURU_VERSION_CONTROLLED_PATH")
+        if env:
+            return Path(env).expanduser().resolve()
+        return None
+
+    @classmethod
+    def _resolve_version_controlled_root(cls) -> Path:
+        project_root = cls._find_project_root()
+        return (project_root / cls.VERSION_CONTROLLED_SUBDIR).resolve()
+
+    @staticmethod
+    def _find_project_root(
+        start: Path | None = None, *, fallback_to_cwd: bool = False
+    ) -> Path:
+        base = (start or Path.cwd()).resolve()
+        git_root: Path | None = None
+        for path in (base, *base.parents):
+            if (path / "pyproject.toml").is_file():
+                return path
+            if git_root is None and (path / ".git").exists():
+                git_root = path
+        if git_root is not None:
+            return git_root
+        if fallback_to_cwd:
+            return base
+        raise ValueError(
+            "Cannot locate pyproject.toml or .git to determine version-controlled root. "
+            "Set FURU_VERSION_CONTROLLED_PATH to override."
+        )
+
+    @staticmethod
+    def _require_namespaces_exist(namespaces: set[str]) -> None:
+        if not namespaces:
+            return
+        missing_sentinel = object()
+        for namespace in namespaces:
+            module_name, _, qualname = namespace.rpartition(".")
+            if not module_name or not qualname:
+                raise ValueError(
+                    "FURU_ALWAYS_RERUN entries must be 'module.QualifiedName', "
+                    f"got {namespace!r}"
+                )
+            target: object = import_module(module_name)
+            for attr in qualname.split("."):
+                value = getattr(target, attr, missing_sentinel)
+                if value is missing_sentinel:
+                    raise ValueError(
+                        "FURU_ALWAYS_RERUN entry does not exist: "
+                        f"{namespace!r}"
+                    )
+                target = value
+
+    @property
+    def raw_dir(self) -> Path:
+        return self.base_root / "raw"
+
+
+FURU_CONFIG = FuruConfig()
+
+
+def get_furu_root(*, version_controlled: bool = False) -> Path:
+    return FURU_CONFIG.get_root(version_controlled=version_controlled)
+
+
+def set_furu_root(path: Path) -> None:
+    FURU_CONFIG.base_root = path.resolve()

{furu-0.0.1 → furu-0.0.2}/src/furu/core/furu.py

@@ -204,11 +204,13 @@ class Furu[T](ABC):
         """Compute hash of this object's content for storage identification."""
         return FuruSerializer.compute_hash(self)
 
-    def _force_recompute(self: Self) -> bool:
-        if not FURU_CONFIG.force_recompute:
+    def _always_rerun(self: Self) -> bool:
+        if FURU_CONFIG.always_rerun_all:
+            return True
+        if not FURU_CONFIG.always_rerun:
             return False
         qualname = f"{self.__class__.__module__}.{self.__class__.__qualname__}"
-        return qualname in FURU_CONFIG.force_recompute
+        return qualname in FURU_CONFIG.always_rerun
 
     def _base_furu_dir(self: Self) -> Path:
         root = FURU_CONFIG.get_root(self.version_controlled)
@@ -333,12 +335,12 @@ class Furu[T](ABC):
                         )
                         migration = MigrationManager.read_migration(base_dir)
 
-                if alias_active and self._force_recompute():
+                if alias_active and self._always_rerun():
                     if migration is not None:
                         self._maybe_detach_alias(
                             directory=base_dir,
                             record=migration,
-                            reason="force_recompute",
+                            reason="always_rerun",
                         )
                     migration = MigrationManager.read_migration(base_dir)
                     alias_active = False
@@ -350,9 +352,9 @@ class Furu[T](ABC):
                 success_marker = StateManager.get_success_marker_path(directory)
                 if success_marker.is_file():
                     # We have a success marker. Check if we can use it.
-                    if self._force_recompute():
+                    if self._always_rerun():
                         self._invalidate_cached_success(
-                            directory, reason="force_recompute enabled"
+                            directory, reason="always_rerun enabled"
                         )
                         # Fall through to normal load
                     else:
@@ -381,9 +383,9 @@ class Furu[T](ABC):
                 needs_reconcile = True
                 if isinstance(state0.result, _StateResultSuccess):
                     # Double check logic if we fell through to here (e.g. race condition or invalidation above)
-                    if self._force_recompute():
+                    if self._always_rerun():
                         self._invalidate_cached_success(
-                            directory, reason="force_recompute enabled"
+                            directory, reason="always_rerun enabled"
                         )
                         state0 = StateManager.read_state(directory)
                     else:

{furu-0.0.1 → furu-0.0.2}/src/furu/storage/state.py

@@ -1008,6 +1008,35 @@ def compute_lock(
         FuruLockNotAcquired: If lock cannot be acquired (after waiting)
         FuruWaitTimeout: If max_wait_time_sec is exceeded
     """
+    def _format_wait_duration(seconds: float) -> str:
+        if seconds < 60.0:
+            return f"{seconds:.1f}s"
+        minutes = seconds / 60.0
+        if minutes < 60.0:
+            return f"{minutes:.1f}m"
+        hours = minutes / 60.0
+        if hours < 24.0:
+            return f"{hours:.1f}h"
+        days = hours / 24.0
+        return f"{days:.1f}d"
+
+    def _describe_wait(attempt: _StateAttempt, waited_sec: float) -> str:
+        label = "last heartbeat"
+        timestamp = attempt.heartbeat_at
+        if attempt.status == "queued":
+            label = "queued at"
+            timestamp = attempt.started_at
+        parsed = StateManager._parse_time(timestamp)
+        timestamp_info = timestamp
+        if parsed is not None:
+            age = (StateManager._utcnow() - parsed).total_seconds()
+            timestamp_info = f"{timestamp} ({_format_wait_duration(age)} ago)"
+        return (
+            "waited "
+            f"{_format_wait_duration(waited_sec)}, {label} {timestamp_info}, "
+            f"status {attempt.status}, backend {attempt.backend}"
+        )
+
     lock_path = StateManager.get_lock_path(directory, StateManager.COMPUTE_LOCK)
 
     lock_fd: int | None = None
@@ -1031,6 +1060,49 @@ def compute_lock(
 
         lock_fd = StateManager.try_lock(lock_path)
         if lock_fd is not None:
+            state = StateManager.read_state(directory)
+            if isinstance(state.result, _StateResultSuccess):
+                StateManager.release_lock(lock_fd, lock_path)
+                raise FuruLockNotAcquired(
+                    "Cannot acquire lock: experiment already succeeded"
+                )
+            if isinstance(state.result, _StateResultFailed):
+                StateManager.release_lock(lock_fd, lock_path)
+                raise FuruLockNotAcquired("Cannot acquire lock: experiment already failed")
+            attempt = state.attempt
+            if (
+                isinstance(attempt, (_StateAttemptQueued, _StateAttemptRunning))
+                and attempt.backend != backend
+            ):
+                StateManager.release_lock(lock_fd, lock_path)
+                lock_fd = None
+                if reconcile_fn is not None:
+                    reconcile_fn(directory)
+                    state = StateManager.read_state(directory)
+                if isinstance(state.result, _StateResultSuccess):
+                    raise FuruLockNotAcquired(
+                        "Cannot acquire lock: experiment already succeeded"
+                    )
+                if isinstance(state.result, _StateResultFailed):
+                    raise FuruLockNotAcquired(
+                        "Cannot acquire lock: experiment already failed"
+                    )
+                attempt = state.attempt
+                if not isinstance(attempt, (_StateAttemptQueued, _StateAttemptRunning)):
+                    continue
+                if attempt.backend == backend:
+                    continue
+                now = time.time()
+                if now >= next_wait_log_at:
+                    waited_sec = now - start_time
+                    logger.info(
+                        "compute_lock: waiting for lock creation %s (%s)",
+                        directory,
+                        _describe_wait(attempt, waited_sec),
+                    )
+                    next_wait_log_at = now + wait_log_every_sec
+                time.sleep(poll_interval_sec)
+                continue
             break
 
         # Lock held by someone else - reconcile and check state
@@ -1064,9 +1136,11 @@ def compute_lock(
         # Active attempt exists - wait for it
         now = time.time()
         if now >= next_wait_log_at:
+            waited_sec = now - start_time
             logger.info(
-                "compute_lock: waiting for lock %s",
+                "compute_lock: waiting for lock %s (%s)",
                 directory,
+                _describe_wait(attempt, waited_sec),
             )
             next_wait_log_at = now + wait_log_every_sec
         time.sleep(poll_interval_sec)

furu-0.0.1/.github/workflows/ci.yml

@@ -1,33 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v4
-
-      - name: Set up Python
-        run: uv python install
-
-      - name: Install bun
-        uses: oven-sh/setup-bun@v2
-
-      - name: Install dependencies
-        run: |
-          uv sync --all-extras
-          cd dashboard-frontend && bun install
-
-      - name: Install e2e dependencies
-        run: make dashboard-install-e2e
-
-      - name: Build frontend artifacts
-        run: make frontend-build
-
-      - name: Run tests
-        run: make test-all

furu-0.0.1/.github/workflows/release.yml

@@ -1,99 +0,0 @@
-name: Release
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - pyproject.toml
-
-permissions:
-  contents: write
-  id-token: write
-
-jobs:
-  release:
-    runs-on: ubuntu-latest
-    environment: pypi
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Install uv
-        uses: astral-sh/setup-uv@v4
-
-      - name: Set up Python
-        run: uv python install
-
-      - name: Install bun
-        uses: oven-sh/setup-bun@v2
-
-      - name: Read version
-        id: version
-        run: |
-          python - <<'PY'
-          import tomllib
-          from pathlib import Path
-
-          data = tomllib.loads(Path("pyproject.toml").read_text())
-          version = data["project"]["version"]
-          print(f"version={version}")
-          Path("version.txt").write_text(version)
-          PY
-          echo "version=$(cat version.txt)" >> $GITHUB_OUTPUT
-
-      - name: Check release
-        id: tag
-        run: |
-          git fetch --tags
-          if git rev-parse "v${{ steps.version.outputs.version }}" >/dev/null 2>&1; then
-            echo "should_release=false" >> $GITHUB_OUTPUT
-            exit 0
-          fi
-
-          if git diff -U0 HEAD^ HEAD -- pyproject.toml | grep -E '^[+-]version = "' >/dev/null; then
-            echo "should_release=true" >> $GITHUB_OUTPUT
-          else
-            echo "should_release=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Install dependencies
-        if: steps.tag.outputs.should_release == 'true'
-        run: |
-          uv sync --all-extras
-          cd dashboard-frontend && bun install
-
-      - name: Install e2e dependencies
-        if: steps.tag.outputs.should_release == 'true'
-        run: make dashboard-install-e2e
-
-      - name: Build frontend
-        if: steps.tag.outputs.should_release == 'true'
-        run: make frontend-build
-
-      - name: Run tests
-        if: steps.tag.outputs.should_release == 'true'
-        run: make test-all
-
-      - name: Build package
-        if: steps.tag.outputs.should_release == 'true'
-        run: uv build
-
-      - name: Create tag
-        if: steps.tag.outputs.should_release == 'true'
-        run: |
-          git tag "v${{ steps.version.outputs.version }}"
-          git push origin "v${{ steps.version.outputs.version }}"
-
-      - name: Publish to PyPI
-        if: steps.tag.outputs.should_release == 'true'
-        uses: pypa/gh-action-pypi-publish@release/v1
-
-      - name: Create GitHub Release
-        if: steps.tag.outputs.should_release == 'true'
-        uses: softprops/action-gh-release@v2
-        with:
-          tag_name: "v${{ steps.version.outputs.version }}"
-          files: dist/*
-          generate_release_notes: true