fixup! refactor(core.utils): use platformdirs for default cache dir

Drop the inline _default_cache_dir() platform branching and call
platformdirs.user_cache_path("cuda-python", appauthor=False) /
"program-cache" instead. The inline version handled the obvious cases
(XDG_CACHE_HOME on Linux, ~/Library/Caches on macOS, %LOCALAPPDATA% on
Windows) but glossed over Windows FOLDERID_* / Known Folder semantics
that platformdirs encodes correctly.

Adds platformdirs >=3.0 as a runtime dep in both pyproject.toml and
pixi.toml. Drops the platform-branch unit tests (we don't re-test
platformdirs' logic) and keeps a thin "we land in the right user-cache
root with the right leaf" assertion plus the end-to-end "default dir is
used when path is omitted" integration test.

Author: cpcloud

cuda_core/cuda/core/utils/_program_cache.py

@@ -19,11 +19,12 @@
 import errno
 import hashlib
 import os
-import sys
 import tempfile
 import threading
 import time
 from pathlib import Path
+
+import platformdirs
 from typing import Iterable, Sequence
 
 from cuda.core._module import ObjectCode
@@ -831,36 +832,24 @@ def _probe(label: str, fn):
 _REPLACE_RETRY_DELAYS = (0.0, 0.005, 0.010, 0.020, 0.050, 0.100)  # ~185ms budget
 
 
-# Sub-path appended to whatever OS-level cache root we discover. Vendor name
-# disambiguates from other "cuda-python" caches a user might have, and the
-# leaf names the artifact ("compiled programs") in case future tooling adds
-# sibling caches under the same vendor root.
-_DEFAULT_CACHE_DIR_LEAF = ("cuda-python", "program-cache")
-
-
 def _default_cache_dir() -> Path:
     """OS-conventional default location for the file-stream cache.
 
-    * Linux / *BSD:   ``$XDG_CACHE_HOME/cuda-python/program-cache``,
-                      defaulting to ``~/.cache/cuda-python/program-cache``.
-    * macOS:          ``~/Library/Caches/cuda-python/program-cache``.
-    * Windows:        ``%LOCALAPPDATA%\\cuda-python\\program-cache``,
-                      defaulting to ``~/AppData/Local/cuda-python/program-cache``.
+    Resolves to the user-cache root for the calling user, with a
+    ``program-cache`` leaf so future tooling can place sibling caches
+    under the same ``cuda-python`` vendor directory:
+
+    * Linux / *BSD: ``$XDG_CACHE_HOME/cuda-python/program-cache``
+      (default ``~/.cache/cuda-python/program-cache``).
+    * macOS:        ``~/Library/Caches/cuda-python/program-cache``.
+    * Windows:      ``%LOCALAPPDATA%\\cuda-python\\program-cache``
+      (Windows uses local AppData -- caches don't roam).
 
-    Implemented inline (no ``platformdirs`` dependency) since cuda_core
-    keeps a deliberately small runtime dep set.
+    Delegates to :mod:`platformdirs`, which encodes the per-platform
+    rules canonically (and tracks corner cases like ``FOLDERID_*`` on
+    Windows that an ad-hoc reimplementation would miss).
     """
-    if _IS_WINDOWS:
-        base = os.environ.get("LOCALAPPDATA")
-        if not base:
-            base = str(Path.home() / "AppData" / "Local")
-        return Path(base, *_DEFAULT_CACHE_DIR_LEAF)
-    if sys.platform == "darwin":
-        return Path.home() / "Library" / "Caches" / Path(*_DEFAULT_CACHE_DIR_LEAF)
-    base = os.environ.get("XDG_CACHE_HOME")
-    if not base:
-        base = str(Path.home() / ".cache")
-    return Path(base, *_DEFAULT_CACHE_DIR_LEAF)
+    return platformdirs.user_cache_path("cuda-python", appauthor=False) / "program-cache"
 
 
 def _replace_with_sharing_retry(tmp_path: Path, target: Path) -> bool:

cuda_core/pixi.toml

@@ -185,6 +185,7 @@ cuda-version = "*"
 numpy = "*"
 cuda-bindings = "*"
 cuda-pathfinder = "*"
+platformdirs = ">=3.0"
 
 [target.linux.tasks.build-cython-tests]
 cmd = ["$PIXI_PROJECT_ROOT/tests/cython/build_tests.sh"]

cuda_core/pyproject.toml

@@ -50,6 +50,7 @@ classifiers = [
 dependencies = [
     "cuda-pathfinder >=1.4.2",
     "numpy",
+    "platformdirs >=3.0",
 ]
 
 [project.optional-dependencies]

cuda_core/tests/test_program_cache.py

@@ -1239,73 +1239,16 @@ def test_filestream_cache_rejects_negative_size_cap(tmp_path):
         FileStreamProgramCache(tmp_path / "fc", max_size_bytes=-1)
 
 
-@pytest.mark.parametrize(
-    "platform, env, home, expected",
-    [
-        pytest.param(
-            "linux",
-            {"XDG_CACHE_HOME": "/explicit/xdg"},
-            "/home/u",
-            "/explicit/xdg/cuda-python/program-cache",
-            id="linux_xdg_set",
-        ),
-        pytest.param(
-            "linux",
-            {},
-            "/home/u",
-            "/home/u/.cache/cuda-python/program-cache",
-            id="linux_xdg_unset",
-        ),
-        pytest.param(
-            "darwin",
-            {},
-            "/Users/u",
-            "/Users/u/Library/Caches/cuda-python/program-cache",
-            id="macos",
-        ),
-    ],
-)
-def test_default_cache_dir_posix(monkeypatch, platform, env, home, expected):
-    from pathlib import Path
-
-    from cuda.core.utils._program_cache import _default_cache_dir
-
-    monkeypatch.setattr("cuda.core.utils._program_cache._IS_WINDOWS", False)
-    monkeypatch.setattr("cuda.core.utils._program_cache.sys.platform", platform)
-    monkeypatch.delenv("XDG_CACHE_HOME", raising=False)
-    monkeypatch.delenv("LOCALAPPDATA", raising=False)
-    for k, v in env.items():
-        monkeypatch.setenv(k, v)
-    monkeypatch.setattr(Path, "home", classmethod(lambda cls: cls(home)))
-
-    assert _default_cache_dir() == Path(expected)
-
-
-def test_default_cache_dir_windows_localappdata_set(monkeypatch):
-    from pathlib import Path
+def test_default_cache_dir_lives_under_user_cache_root():
+    """We delegate per-platform path resolution to ``platformdirs``, so we
+    only verify the cuda-python-owned suffix; the OS-specific bits are
+    platformdirs' responsibility."""
+    import platformdirs
 
     from cuda.core.utils._program_cache import _default_cache_dir
 
-    monkeypatch.setattr("cuda.core.utils._program_cache._IS_WINDOWS", True)
-    monkeypatch.setattr("cuda.core.utils._program_cache.sys.platform", "win32")
-    monkeypatch.delenv("XDG_CACHE_HOME", raising=False)
-    monkeypatch.setenv("LOCALAPPDATA", "/fake/appdata/local")
-
-    assert _default_cache_dir() == Path("/fake/appdata/local/cuda-python/program-cache")
-
-
-def test_default_cache_dir_windows_localappdata_unset_falls_back_to_home(monkeypatch):
-    from pathlib import Path
-
-    from cuda.core.utils._program_cache import _default_cache_dir
-
-    monkeypatch.setattr("cuda.core.utils._program_cache._IS_WINDOWS", True)
-    monkeypatch.setattr("cuda.core.utils._program_cache.sys.platform", "win32")
-    monkeypatch.delenv("XDG_CACHE_HOME", raising=False)
-    monkeypatch.delenv("LOCALAPPDATA", raising=False)
-    monkeypatch.setattr(Path, "home", classmethod(lambda cls: cls("/fake/userprofile")))
-
-    assert _default_cache_dir() == Path("/fake/userprofile/AppData/Local/cuda-python/program-cache")
+    expected = platformdirs.user_cache_path("cuda-python", appauthor=False) / "program-cache"
+    assert _default_cache_dir() == expected
 
 
 def test_filestream_cache_uses_default_dir_when_path_omitted(tmp_path, monkeypatch):