platformdirs 4.13.2__tar.gz → 4.13.4__tar.gz

{platformdirs-4.13.2 → platformdirs-4.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: platformdirs
-Version: 4.13.2
+Version: 4.13.4
 Summary: A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`.
 Project-URL: Changelog, https://platformdirs.readthedocs.io/en/latest/changelog.html
 Project-URL: Documentation, https://platformdirs.readthedocs.io

{platformdirs-4.13.2 → platformdirs-4.13.4}/src/platformdirs/android.py

@@ -189,7 +189,7 @@ def _android_folder() -> str | None:
                 /data/(?:data|user/\d+)  # internal storage of the primary user or of user N
                 /[^/]+                   # package name, one path segment
             )
-            /files                       # the files directory the interpreter runs from
+            /files(?=/|\Z)               # the files directory the interpreter runs from
             """,
             re.VERBOSE,
         )
@@ -209,7 +209,7 @@ def _android_folder() -> str | None:
                 /(?:data|user/\d+)             # the primary user or user N
                 /[^/]+                         # package name, one path segment
             )
-            /files                             # the files directory the interpreter runs from
+            /files(?=/|\Z)                     # the files directory the interpreter runs from
             """,
             re.VERBOSE,
         )

{platformdirs-4.13.2 → platformdirs-4.13.4}/src/platformdirs/ios.py

@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-import os.path
-
+from ._xdg import _expand_user
 from .api import PlatformDirsABC
 
 
@@ -23,7 +22,7 @@ class IOS(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_data_dir(self) -> str:
         """Data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``."""
-        return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support"), private=True)  # ruff:ignore[os-path-expanduser]  # Path.expanduser raises on an unknown home
+        return self._append_app_name_and_version(_expand_user("~/Library/Application Support"), private=True)
 
     @property
     def site_data_dir(self) -> str:
@@ -43,7 +42,7 @@ class IOS(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_cache_dir(self) -> str:
         """Cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``."""
-        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches"), private=True)  # ruff:ignore[os-path-expanduser]  # Path.expanduser raises on an unknown home
+        return self._append_app_name_and_version(_expand_user("~/Library/Caches"), private=True)
 
     @property
     def site_cache_dir(self) -> str:
@@ -63,7 +62,7 @@ class IOS(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_log_dir(self) -> str:
         """Log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``."""
-        return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs"), private=True)  # ruff:ignore[os-path-expanduser]  # Path.expanduser raises on an unknown home
+        return self._append_app_name_and_version(_expand_user("~/Library/Logs"), private=True)
 
     @property
     def site_log_dir(self) -> str:
@@ -73,53 +72,53 @@ class IOS(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_documents_dir(self) -> str:
         """Documents directory tied to the user, e.g. ``~/Documents``."""
-        return os.path.expanduser("~/Documents")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents")
 
     # The app container has Documents but no other media folder, so the rest live inside it, as Qt places them.
     @property
     def user_downloads_dir(self) -> str:
         """Downloads directory tied to the user, e.g. ``~/Documents/Downloads``."""
-        return os.path.expanduser("~/Documents/Downloads")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Downloads")
 
     @property
     def user_pictures_dir(self) -> str:
         """Pictures directory tied to the user, e.g. ``~/Documents/Pictures``."""
-        return os.path.expanduser("~/Documents/Pictures")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Pictures")
 
     @property
     def user_videos_dir(self) -> str:
         """Videos directory tied to the user, e.g. ``~/Documents/Movies``."""
-        return os.path.expanduser("~/Documents/Movies")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Movies")
 
     @property
     def user_music_dir(self) -> str:
         """Music directory tied to the user, e.g. ``~/Documents/Music``."""
-        return os.path.expanduser("~/Documents/Music")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Music")
 
     @property
     def user_desktop_dir(self) -> str:
         """Desktop directory tied to the user, e.g. ``~/Documents/Desktop``."""
-        return os.path.expanduser("~/Documents/Desktop")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Desktop")
 
     @property
     def user_projects_dir(self) -> str:
         """Projects directory tied to the user, e.g. ``~/Documents/Projects``."""
-        return os.path.expanduser("~/Documents/Projects")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Projects")
 
     @property
     def user_publicshare_dir(self) -> str:
         """Public share directory tied to the user, e.g. ``~/Documents/Public``."""
-        return os.path.expanduser("~/Documents/Public")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Public")
 
     @property
     def user_templates_dir(self) -> str:
         """Templates directory tied to the user, e.g. ``~/Documents/Templates``."""
-        return os.path.expanduser("~/Documents/Templates")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Documents/Templates")
 
     @property
     def user_fonts_dir(self) -> str:
         """Fonts directory tied to the user, e.g. ``~/Library/Fonts``."""
-        return os.path.expanduser("~/Library/Fonts")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Library/Fonts")
 
     @property
     def user_preference_dir(self) -> str:
@@ -130,7 +129,7 @@ class IOS(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_bin_dir(self) -> str:
         """Bin directory tied to the user, e.g. ``~/.local/bin``."""
-        return os.path.expanduser("~/.local/bin")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/.local/bin")
 
     @property
     def site_bin_dir(self) -> str:
@@ -140,7 +139,7 @@ class IOS(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_applications_dir(self) -> str:
         """Applications directory tied to the user, e.g. ``~/Applications``."""
-        return os.path.expanduser("~/Applications")  # ruff:ignore[os-path-expanduser]
+        return _expand_user("~/Applications")
 
     @property
     def site_applications_dir(self) -> str:
@@ -150,7 +149,7 @@ class IOS(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_runtime_dir(self) -> str:
         """Runtime directory tied to the user, e.g. ``~/tmp/$appname/$version``."""
-        return self._append_app_name_and_version(os.path.expanduser("~/tmp"), private=True)  # ruff:ignore[os-path-expanduser]  # Path.expanduser raises on an unknown home
+        return self._append_app_name_and_version(_expand_user("~/tmp"), private=True)
 
     @property
     def site_runtime_dir(self) -> str:

{platformdirs-4.13.2 → platformdirs-4.13.4}/src/platformdirs/testing.py

@@ -39,6 +39,8 @@ def isolated_dirs(root: str | os.PathLike[str]) -> Generator[Path, None, None]:
     ``PlatformDirs("app", version="1.0").user_config_path`` becomes ``<root>/user_config/app/1.0``. Every thread of the
     current process sees the change, and subprocesses do not.
 
+    On Unix, ``use_site_for_root`` is ignored inside the context so user and site directories keep separate kinds.
+
     :param root: directory that holds the redirected directories
 
     :returns: ``root`` as a :class:`~pathlib.Path`
@@ -51,11 +53,11 @@ def isolated_dirs(root: str | os.PathLike[str]) -> Generator[Path, None, None]:
         )
         for name in PlatformDirsABC.__abstractmethods__
     }
-    # Unix and macOS build the site lists from search paths; the base versions derive them from the redirected dirs.
+    # Base site lists follow the redirected dirs, and disabling root redirection keeps user and site kinds separate.
     patches |= {
         name: value
         for name, value in vars(PlatformDirsABC).items()
-        if name.startswith("_site_") and name.endswith("_dirs")
+        if name == "_use_site" or (name.startswith("_site_") and name.endswith("_dirs"))
     }
     cls = platformdirs.PlatformDirs
     saved = {name: vars(cls)[name] for name in patches if name in vars(cls)}

{platformdirs-4.13.2 → platformdirs-4.13.4}/src/platformdirs/version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '4.13.2'
-__version_tuple__ = version_tuple = (4, 13, 2)
+__version__ = version = '4.13.4'
+__version_tuple__ = version_tuple = (4, 13, 4)
 
 __commit_id__ = commit_id = None

{platformdirs-4.13.2 → platformdirs-4.13.4}/src/platformdirs/windows.py

@@ -9,6 +9,7 @@ from functools import cache
 from pathlib import Path
 from typing import TYPE_CHECKING, Final
 
+from ._xdg import _expand_user
 from .api import PlatformDirsABC
 
 if TYPE_CHECKING:
@@ -139,7 +140,7 @@ class Windows(PlatformDirsABC):  # ruff:ignore[too-many-public-methods]
     @property
     def user_projects_dir(self) -> str:
         r"""Projects directory tied to the user, e.g. ``%USERPROFILE%\Projects``."""
-        return os.path.normpath(os.path.expanduser("~/Projects"))  # ruff:ignore[os-path-expanduser]
+        return os.path.normpath(_expand_user("~/Projects"))
 
     @property
     def user_publicshare_dir(self) -> str:

{platformdirs-4.13.2 → platformdirs-4.13.4}/tests/test_android.py

@@ -341,3 +341,29 @@ def test_android_opinion_subdir_created_private(
     mocker.patch("platformdirs.android._android_folder", return_value=str(tmp_path), autospec=True)
     subdir = Path(getattr(Android(appname="app", ensure_exists=True), prop)).name
     assert modes(tmp_path) == {"cache": 0o700, "cache/app": 0o700, f"cache/app/{subdir}": 0o700}
+
+
+@pytest.mark.usefixtures("_clear_android_caches")
+@pytest.mark.parametrize(
+    "path",
+    [
+        pytest.param("/data/data/org.example.app/filesystem", id="internal-prefix"),
+        pytest.param("/data/user/10/org.example.app/files-backup/lib", id="secondary-user-prefix"),
+        pytest.param("/data/data/org.example.app/files\n", id="internal-newline"),
+        pytest.param(
+            "/mnt/expand/8e06fc2f-a86a-44e8-81ce-109e0eedd5ed/user/10/org.example.app/filesystem",
+            id="adopted-prefix",
+        ),
+        pytest.param(
+            "/mnt/expand/8e06fc2f-a86a-44e8-81ce-109e0eedd5ed/user/10/org.example.app/files\n",
+            id="adopted-newline",
+        ),
+    ],
+)
+def test_android_folder_requires_files_segment(
+    mocker: MockerFixture, monkeypatch: pytest.MonkeyPatch, path: str
+) -> None:
+    mocker.patch.dict(sys.modules, {"jnius": None})
+    monkeypatch.setattr(sys, "path", [path])
+    with pytest.raises(RuntimeError, match=r"^cannot find the Android app folder"):
+        _ = Android().user_data_dir

{platformdirs-4.13.2 → platformdirs-4.13.4}/tests/test_ios.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+import re
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -124,7 +125,7 @@ def test_ios_ensure_exists_without_home_creates_nothing(
     monkeypatch.delenv("HOME", raising=False)
     mocker.patch.object(pwd, "getpwuid", side_effect=KeyError("getpwuid(): uid not found"))
     monkeypatch.chdir(tmp_path)
-    with pytest.raises(RuntimeError, match=r"^could not determine the home directory, refusing to create '~/"):
+    with pytest.raises(RuntimeError, match=r"^could not determine the home directory"):
         _ = IOS(appname="app", ensure_exists=True).user_data_dir
     assert list(tmp_path.iterdir()) == []
 
@@ -141,3 +142,22 @@ def test_ios_ensure_exists_without_home_creates_nothing(
 def test_ios_ignores_xdg_variables(monkeypatch: pytest.MonkeyPatch, container: Path, env_var: str, func: str) -> None:
     monkeypatch.setenv(env_var, "/xdg")
     assert Path(getattr(IOS(), func)).is_relative_to(container)
+
+
+@pytest.mark.usefixtures("_unknown_home")
+@pytest.mark.parametrize(
+    ("prop", "path"),
+    [
+        pytest.param("user_data_dir", "~/Library/Application Support", id="data"),
+        pytest.param("user_config_dir", "~/Library/Application Support", id="config"),
+        pytest.param("user_cache_dir", "~/Library/Caches", id="cache"),
+        pytest.param("user_log_dir", "~/Library/Logs", id="log"),
+        pytest.param("user_runtime_dir", "~/tmp", id="runtime"),
+        pytest.param("user_documents_dir", "~/Documents", id="documents"),
+        pytest.param("user_applications_dir", "~/Applications", id="applications"),
+        pytest.param("user_fonts_dir", "~/Library/Fonts", id="fonts"),
+    ],
+)
+def test_without_home_ios_dir_raises(prop: str, path: str) -> None:
+    with pytest.raises(RuntimeError, match=re.escape(f"could not determine the home directory for {path!r}")):
+        _ = getattr(IOS(appname="app", version="1.0"), prop)

{platformdirs-4.13.2 → platformdirs-4.13.4}/tests/test_testing.py

@@ -10,6 +10,7 @@ import pytest
 import platformdirs
 from platformdirs.android import Android
 from platformdirs.testing import isolated_dirs
+from platformdirs.unix import Unix
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -141,3 +142,57 @@ def test_isolated_dirs_nested_restores_outer(tmp_path: Path) -> None:
         with isolated_dirs(tmp_path / "inner"):
             pass
         assert platformdirs.user_data_path("app") == tmp_path / "outer" / "user_data" / "app"
+
+
+@pytest.mark.usefixtures("_unix_root")
+@pytest.mark.parametrize(
+    ("kind", "suffix"),
+    [
+        pytest.param("user_data", "app/1.0", id="data"),
+        pytest.param("user_config", "app/1.0", id="config"),
+        pytest.param("user_preference", "app/1.0", id="preference"),
+        pytest.param("user_applications", "", id="applications"),
+    ],
+)
+@pytest.mark.parametrize("multipath", [pytest.param(False, id="single"), pytest.param(True, id="multiple")])
+def test_isolated_dirs_root_paths_follow_redirected_dirs(
+    tmp_path: Path, kind: str, suffix: str, multipath: bool
+) -> None:
+    dirs = Unix("app", version="1.0", multipath=multipath, use_site_for_root=True)
+    expected = tmp_path / kind / suffix
+    with isolated_dirs(tmp_path):
+        assert getattr(dirs, f"{kind}_dir") == str(expected)
+        assert getattr(dirs, f"{kind}_path") == expected
+
+
+@pytest.mark.usefixtures("_unix_root")
+def test_isolated_dirs_root_iter_config_paths(tmp_path: Path) -> None:
+    with isolated_dirs(tmp_path):
+        assert list(Unix("app", use_site_for_root=True).iter_config_paths()) == [
+            tmp_path / "user_config/app",
+            tmp_path / "site_config/app",
+        ]
+
+
+@pytest.mark.usefixtures("_unix_root")
+def test_isolated_dirs_restores_root_redirection(tmp_path: Path, mocker: MockerFixture) -> None:
+    mocker.patch.dict(os.environ, {"XDG_CONFIG_HOME": "/user", "XDG_CONFIG_DIRS": "/site"})
+    dirs = Unix("app", use_site_for_root=True)
+    with isolated_dirs(tmp_path):
+        pass
+    assert dirs.user_config_dir == dirs.site_config_dir
+
+
+@pytest.mark.usefixtures("_unix_root")
+def test_isolated_dirs_nested_root_restores_after_exception(tmp_path: Path) -> None:
+    dirs = Unix("app", use_site_for_root=True)
+    with isolated_dirs(tmp_path):
+        with pytest.raises(LookupError), isolated_dirs(tmp_path / "inner"):
+            raise LookupError
+        assert dirs.user_config_path == tmp_path / "user_config/app"
+
+
+@pytest.fixture
+def _unix_root(mocker: MockerFixture) -> None:
+    mocker.patch("platformdirs.PlatformDirs", Unix)
+    mocker.patch("platformdirs.unix.getuid", return_value=0)

{platformdirs-4.13.2 → platformdirs-4.13.4}/tests/test_unix.py

@@ -34,7 +34,7 @@ def _reload_after_test() -> typing.Iterator[None]:
 
 
 @pytest.fixture
-def _as_root(mocker: MockerFixture) -> None:
+def _as_root(mocker: MockerFixture, _clear_xdg_env: None) -> None:
     mocker.patch("platformdirs.unix.getuid", return_value=0)
 
 

{platformdirs-4.13.2 → platformdirs-4.13.4}/tests/test_windows.py

@@ -148,6 +148,14 @@ def test_get_win_folder_from_env_vars_public_fallback(mocker: MockerFixture, env
     assert get_win_folder_from_env_vars("CSIDL_PUBLIC") == str(Path("C:/Users/Public"))
 
 
+def test_user_projects_dir_raises_without_home(mocker: MockerFixture) -> None:
+    # os.path.expanduser leaves the tilde in place when the home is unknown (only Path.expanduser raises),
+    # so the Projects directory must not come back as a literal ~ path.
+    mocker.patch.object(os.path, "expanduser", return_value="~/Projects")
+    with pytest.raises(RuntimeError, match=r"^could not determine the home directory for '~/Projects'"):
+        _ = Windows().user_projects_dir
+
+
 def test_roaming_uses_appdata(mocker: MockerFixture) -> None:
     mock = mocker.patch("platformdirs.windows.get_win_folder", side_effect=lambda csidl: _WIN_FOLDERS[csidl])
     _result = Windows(appname="foo", roaming=True).user_data_dir