shortcutxl 0.3.76 → 0.3.78

package/xll/python/Lib/site-packages/pip/_vendor/platformdirs/__main__.py

@@ -15,10 +15,21 @@ PROPS = (
     "user_pictures_dir",
     "user_videos_dir",
     "user_music_dir",
+    "user_projects_dir",
+    "user_publicshare_dir",
+    "user_templates_dir",
+    "user_fonts_dir",
+    "user_preference_dir",
+    "user_bin_dir",
+    "site_bin_dir",
+    "user_applications_dir",
     "user_runtime_dir",
     "site_data_dir",
     "site_config_dir",
     "site_cache_dir",
+    "site_state_dir",
+    "site_log_dir",
+    "site_applications_dir",
     "site_runtime_dir",
 )
 

package/xll/python/Lib/site-packages/pip/_vendor/platformdirs/_xdg.py

@@ -0,0 +1,171 @@
+"""XDG environment variable mixin for Unix and macOS."""
+
+from __future__ import annotations
+
+import os
+
+from .api import PlatformDirsABC
+
+
+class XDGMixin(PlatformDirsABC):
+    """Mixin that checks XDG environment variables, falling back to platform-specific defaults via ``super()``."""
+
+    @property
+    def user_data_dir(self) -> str:
+        """:returns: data directory tied to the user, from ``$XDG_DATA_HOME`` if set, else platform default"""
+        if path := os.environ.get("XDG_DATA_HOME", "").strip():
+            return self._append_app_name_and_version(path)
+        return super().user_data_dir
+
+    @property
+    def _site_data_dirs(self) -> list[str]:
+        if xdg_dirs := os.environ.get("XDG_DATA_DIRS", "").strip():
+            return [self._append_app_name_and_version(p) for p in xdg_dirs.split(os.pathsep) if p.strip()]
+        return super()._site_data_dirs
+
+    @property
+    def site_data_dir(self) -> str:
+        """:returns: data directories shared by users, from ``$XDG_DATA_DIRS`` if set, else platform default"""
+        dirs = self._site_data_dirs
+        return os.pathsep.join(dirs) if self.multipath else dirs[0]
+
+    @property
+    def user_config_dir(self) -> str:
+        """:returns: config directory tied to the user, from ``$XDG_CONFIG_HOME`` if set, else platform default"""
+        if path := os.environ.get("XDG_CONFIG_HOME", "").strip():
+            return self._append_app_name_and_version(path)
+        return super().user_config_dir
+
+    @property
+    def _site_config_dirs(self) -> list[str]:
+        if xdg_dirs := os.environ.get("XDG_CONFIG_DIRS", "").strip():
+            return [self._append_app_name_and_version(p) for p in xdg_dirs.split(os.pathsep) if p.strip()]
+        return super()._site_config_dirs
+
+    @property
+    def site_config_dir(self) -> str:
+        """:returns: config directories shared by users, from ``$XDG_CONFIG_DIRS`` if set, else platform default"""
+        dirs = self._site_config_dirs
+        return os.pathsep.join(dirs) if self.multipath else dirs[0]
+
+    @property
+    def user_cache_dir(self) -> str:
+        """:returns: cache directory tied to the user, from ``$XDG_CACHE_HOME`` if set, else platform default"""
+        if path := os.environ.get("XDG_CACHE_HOME", "").strip():
+            return self._append_app_name_and_version(path)
+        return super().user_cache_dir
+
+    @property
+    def user_state_dir(self) -> str:
+        """:returns: state directory tied to the user, from ``$XDG_STATE_HOME`` if set, else platform default"""
+        if path := os.environ.get("XDG_STATE_HOME", "").strip():
+            return self._append_app_name_and_version(path)
+        return super().user_state_dir
+
+    @property
+    def user_runtime_dir(self) -> str:
+        """:returns: runtime directory tied to the user, from ``$XDG_RUNTIME_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_RUNTIME_DIR", "").strip():
+            return self._append_app_name_and_version(path)
+        return super().user_runtime_dir
+
+    @property
+    def site_runtime_dir(self) -> str:
+        """:returns: runtime directory shared by users, from ``$XDG_RUNTIME_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_RUNTIME_DIR", "").strip():
+            return self._append_app_name_and_version(path)
+        return super().site_runtime_dir
+
+    @property
+    def user_documents_dir(self) -> str:
+        """:returns: documents directory tied to the user, from ``$XDG_DOCUMENTS_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_DOCUMENTS_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111
+        return super().user_documents_dir
+
+    @property
+    def user_downloads_dir(self) -> str:
+        """:returns: downloads directory tied to the user, from ``$XDG_DOWNLOAD_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_DOWNLOAD_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111
+        return super().user_downloads_dir
+
+    @property
+    def user_pictures_dir(self) -> str:
+        """:returns: pictures directory tied to the user, from ``$XDG_PICTURES_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_PICTURES_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111
+        return super().user_pictures_dir
+
+    @property
+    def user_videos_dir(self) -> str:
+        """:returns: videos directory tied to the user, from ``$XDG_VIDEOS_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_VIDEOS_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111
+        return super().user_videos_dir
+
+    @property
+    def user_music_dir(self) -> str:
+        """:returns: music directory tied to the user, from ``$XDG_MUSIC_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_MUSIC_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111
+        return super().user_music_dir
+
+    @property
+    def user_desktop_dir(self) -> str:
+        """:returns: desktop directory tied to the user, from ``$XDG_DESKTOP_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_DESKTOP_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111
+        return super().user_desktop_dir
+
+    @property
+    def user_projects_dir(self) -> str:
+        """:returns: projects directory tied to the user, from ``$XDG_PROJECTS_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_PROJECTS_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111  # API returns str, not Path
+        return super().user_projects_dir
+
+    @property
+    def user_publicshare_dir(self) -> str:
+        """:returns: public share directory tied to the user, from ``$XDG_PUBLICSHARE_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_PUBLICSHARE_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111  # API returns str, not Path
+        return super().user_publicshare_dir
+
+    @property
+    def user_templates_dir(self) -> str:
+        """:returns: templates directory tied to the user, from ``$XDG_TEMPLATES_DIR`` if set, else platform default"""
+        if path := os.environ.get("XDG_TEMPLATES_DIR", "").strip():
+            return os.path.expanduser(path)  # noqa: PTH111  # API returns str, not Path
+        return super().user_templates_dir
+
+    @property
+    def user_fonts_dir(self) -> str:
+        """:returns: fonts directory tied to the user, from ``$XDG_DATA_HOME/fonts`` if set, else platform default"""
+        if path := os.environ.get("XDG_DATA_HOME", "").strip():
+            return f"{os.path.expanduser(path)}/fonts"  # noqa: PTH111  # API returns str, not Path
+        return super().user_fonts_dir
+
+    @property
+    def user_applications_dir(self) -> str:
+        """:returns: applications directory tied to the user, from ``$XDG_DATA_HOME`` if set, else platform default"""
+        if path := os.environ.get("XDG_DATA_HOME", "").strip():
+            return os.path.join(os.path.expanduser(path), "applications")  # noqa: PTH111, PTH118
+        return super().user_applications_dir
+
+    @property
+    def _site_applications_dirs(self) -> list[str]:
+        if xdg_dirs := os.environ.get("XDG_DATA_DIRS", "").strip():
+            return [os.path.join(p, "applications") for p in xdg_dirs.split(os.pathsep) if p.strip()]  # noqa: PTH118
+        return super()._site_applications_dirs
+
+    @property
+    def site_applications_dir(self) -> str:
+        """:returns: applications directories shared by users, from ``$XDG_DATA_DIRS`` if set, else platform default"""
+        dirs = self._site_applications_dirs
+        return os.pathsep.join(dirs) if self.multipath else dirs[0]
+
+
+__all__ = [
+    "XDGMixin",
+]

package/xll/python/Lib/site-packages/pip/_vendor/platformdirs/android.py

@@ -11,114 +11,165 @@ from typing import TYPE_CHECKING, cast
 from .api import PlatformDirsABC
 
 
-class Android(PlatformDirsABC):
-    """
-    Follows the guidance `from here <https://android.stackexchange.com/a/216132>`_.
+class Android(PlatformDirsABC):  # noqa: PLR0904
+    """Platform directories for Android.
+
+    Follows the guidance `from here <https://android.stackexchange.com/a/216132>`_. Directories are typically located
+    under the app's private storage (``/data/user/<userid>/<packagename>/``).
 
     Makes use of the `appname <platformdirs.api.PlatformDirsABC.appname>`, `version
-    <platformdirs.api.PlatformDirsABC.version>`, `ensure_exists <platformdirs.api.PlatformDirsABC.ensure_exists>`.
+    <platformdirs.api.PlatformDirsABC.version>`, `opinion <platformdirs.api.PlatformDirsABC.opinion>`, `ensure_exists
+    <platformdirs.api.PlatformDirsABC.ensure_exists>`.
 
     """
 
     @property
     def user_data_dir(self) -> str:
-        """:return: data directory tied to the user, e.g. ``/data/user/<userid>/<packagename>/files/<AppName>``"""
+        """:returns: data directory tied to the user, e.g. ``/data/user/<userid>/<packagename>/files/<AppName>``"""
         return self._append_app_name_and_version(cast("str", _android_folder()), "files")
 
     @property
     def site_data_dir(self) -> str:
-        """:return: data directory shared by users, same as `user_data_dir`"""
+        """:returns: data directory shared by users, same as `user_data_dir`"""
         return self.user_data_dir
 
     @property
     def user_config_dir(self) -> str:
-        """
-        :return: config directory tied to the user, e.g. \
-        ``/data/user/<userid>/<packagename>/shared_prefs/<AppName>``
-        """
+        """:returns: config directory tied to the user, e.g. ``/data/user/<userid>/<packagename>/shared_prefs/<AppName>``"""
         return self._append_app_name_and_version(cast("str", _android_folder()), "shared_prefs")
 
     @property
     def site_config_dir(self) -> str:
-        """:return: config directory shared by the users, same as `user_config_dir`"""
+        """:returns: config directory shared by users, same as `user_config_dir`"""
         return self.user_config_dir
 
     @property
     def user_cache_dir(self) -> str:
-        """:return: cache directory tied to the user, e.g.,``/data/user/<userid>/<packagename>/cache/<AppName>``"""
+        """:returns: cache directory tied to the user, e.g.,``/data/user/<userid>/<packagename>/cache/<AppName>``"""
         return self._append_app_name_and_version(cast("str", _android_folder()), "cache")
 
     @property
     def site_cache_dir(self) -> str:
-        """:return: cache directory shared by users, same as `user_cache_dir`"""
+        """:returns: cache directory shared by users, same as `user_cache_dir`"""
         return self.user_cache_dir
 
     @property
     def user_state_dir(self) -> str:
-        """:return: state directory tied to the user, same as `user_data_dir`"""
+        """:returns: state directory tied to the user, same as `user_data_dir`"""
         return self.user_data_dir
 
+    @property
+    def site_state_dir(self) -> str:
+        """:returns: state directory shared by users, same as `user_state_dir`"""
+        return self.user_state_dir
+
     @property
     def user_log_dir(self) -> str:
-        """
-        :return: log directory tied to the user, same as `user_cache_dir` if not opinionated else ``log`` in it,
-          e.g. ``/data/user/<userid>/<packagename>/cache/<AppName>/log``
-        """
+        """:returns: log directory tied to the user, same as `user_cache_dir` if not opinionated else ``log`` in it, e.g. ``/data/user/<userid>/<packagename>/cache/<AppName>/log``"""
         path = self.user_cache_dir
         if self.opinion:
             path = os.path.join(path, "log")  # noqa: PTH118
+            self._optionally_create_directory(path)
         return path
 
+    @property
+    def site_log_dir(self) -> str:
+        """:returns: log directory shared by users, same as `user_log_dir`"""
+        return self.user_log_dir
+
     @property
     def user_documents_dir(self) -> str:
-        """:return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``"""
+        """:returns: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``"""
         return _android_documents_folder()
 
     @property
     def user_downloads_dir(self) -> str:
-        """:return: downloads directory tied to the user e.g. ``/storage/emulated/0/Downloads``"""
+        """:returns: downloads directory tied to the user e.g. ``/storage/emulated/0/Downloads``"""
         return _android_downloads_folder()
 
     @property
     def user_pictures_dir(self) -> str:
-        """:return: pictures directory tied to the user e.g. ``/storage/emulated/0/Pictures``"""
+        """:returns: pictures directory tied to the user e.g. ``/storage/emulated/0/Pictures``"""
         return _android_pictures_folder()
 
     @property
     def user_videos_dir(self) -> str:
-        """:return: videos directory tied to the user e.g. ``/storage/emulated/0/DCIM/Camera``"""
+        """:returns: videos directory tied to the user e.g. ``/storage/emulated/0/DCIM/Camera``"""
         return _android_videos_folder()
 
     @property
     def user_music_dir(self) -> str:
-        """:return: music directory tied to the user e.g. ``/storage/emulated/0/Music``"""
+        """:returns: music directory tied to the user e.g. ``/storage/emulated/0/Music``"""
         return _android_music_folder()
 
     @property
     def user_desktop_dir(self) -> str:
-        """:return: desktop directory tied to the user e.g. ``/storage/emulated/0/Desktop``"""
+        """:returns: desktop directory tied to the user e.g. ``/storage/emulated/0/Desktop``"""
         return "/storage/emulated/0/Desktop"
 
+    @property
+    def user_projects_dir(self) -> str:
+        """:returns: projects directory tied to the user e.g. ``/storage/emulated/0/Projects``"""
+        return "/storage/emulated/0/Projects"
+
+    @property
+    def user_publicshare_dir(self) -> str:
+        """:returns: public share directory tied to the user e.g. ``/storage/emulated/0/Public``"""
+        return "/storage/emulated/0/Public"
+
+    @property
+    def user_templates_dir(self) -> str:
+        """:returns: templates directory tied to the user e.g. ``/storage/emulated/0/Templates``"""
+        return "/storage/emulated/0/Templates"
+
+    @property
+    def user_fonts_dir(self) -> str:
+        """:returns: fonts directory tied to the user e.g. ``/storage/emulated/0/fonts``"""
+        return "/storage/emulated/0/fonts"
+
+    @property
+    def user_preference_dir(self) -> str:
+        """:returns: preference directory tied to the user, same as ``user_config_dir``"""
+        return self.user_config_dir
+
+    @property
+    def user_bin_dir(self) -> str:
+        """:returns: bin directory tied to the user, e.g. ``/data/user/<userid>/<packagename>/files/bin``"""
+        return os.path.join(cast("str", _android_folder()), "files", "bin")  # noqa: PTH118
+
+    @property
+    def site_bin_dir(self) -> str:
+        """:returns: bin directory shared by users, same as `user_bin_dir`"""
+        return self.user_bin_dir
+
+    @property
+    def user_applications_dir(self) -> str:
+        """:returns: applications directory tied to the user, same as `user_data_dir`"""
+        return self.user_data_dir
+
+    @property
+    def site_applications_dir(self) -> str:
+        """:returns: applications directory shared by users, same as `user_applications_dir`"""
+        return self.user_applications_dir
+
     @property
     def user_runtime_dir(self) -> str:
-        """
-        :return: runtime directory tied to the user, same as `user_cache_dir` if not opinionated else ``tmp`` in it,
-          e.g. ``/data/user/<userid>/<packagename>/cache/<AppName>/tmp``
-        """
+        """:returns: runtime directory tied to the user, same as `user_cache_dir` if not opinionated else ``tmp`` in it, e.g. ``/data/user/<userid>/<packagename>/cache/<AppName>/tmp``"""
         path = self.user_cache_dir
         if self.opinion:
             path = os.path.join(path, "tmp")  # noqa: PTH118
+            self._optionally_create_directory(path)
         return path
 
     @property
     def site_runtime_dir(self) -> str:
-        """:return: runtime directory shared by users, same as `user_runtime_dir`"""
+        """:returns: runtime directory shared by users, same as `user_runtime_dir`"""
         return self.user_runtime_dir
 
 
 @lru_cache(maxsize=1)
 def _android_folder() -> str | None:  # noqa: C901
-    """:return: base folder for the Android OS or None if it cannot be found"""
+    """:returns: base folder for the Android OS or None if it cannot be found"""
     result: str | None = None
     # type checker isn't happy with our "import android", just don't do this when type checking see
     # https://stackoverflow.com/a/61394121
@@ -135,7 +186,7 @@ def _android_folder() -> str | None:  # noqa: C901
         try:
             # ...and fall back to using plain pyjnius, if python4android isn't available or doesn't deliver any useful
             # result...
-            from jnius import autoclass  # noqa: PLC0415
+            from jnius import autoclass  # noqa: PLC0415  # ty: ignore[unresolved-import]
 
             context = autoclass("android.content.Context")
             result = context.getFilesDir().getParentFile().getAbsolutePath()
@@ -166,10 +217,10 @@ def _android_folder() -> str | None:  # noqa: C901
 
 @lru_cache(maxsize=1)
 def _android_documents_folder() -> str:
-    """:return: documents folder for the Android OS"""
+    """:returns: documents folder for the Android OS"""
     # Get directories with pyjnius
     try:
-        from jnius import autoclass  # noqa: PLC0415
+        from jnius import autoclass  # noqa: PLC0415  # ty: ignore[unresolved-import]
 
         context = autoclass("android.content.Context")
         environment = autoclass("android.os.Environment")
@@ -182,10 +233,10 @@ def _android_documents_folder() -> str:
 
 @lru_cache(maxsize=1)
 def _android_downloads_folder() -> str:
-    """:return: downloads folder for the Android OS"""
+    """:returns: downloads folder for the Android OS"""
     # Get directories with pyjnius
     try:
-        from jnius import autoclass  # noqa: PLC0415
+        from jnius import autoclass  # noqa: PLC0415  # ty: ignore[unresolved-import]
 
         context = autoclass("android.content.Context")
         environment = autoclass("android.os.Environment")
@@ -198,10 +249,10 @@ def _android_downloads_folder() -> str:
 
 @lru_cache(maxsize=1)
 def _android_pictures_folder() -> str:
-    """:return: pictures folder for the Android OS"""
+    """:returns: pictures folder for the Android OS"""
     # Get directories with pyjnius
     try:
-        from jnius import autoclass  # noqa: PLC0415
+        from jnius import autoclass  # noqa: PLC0415  # ty: ignore[unresolved-import]
 
         context = autoclass("android.content.Context")
         environment = autoclass("android.os.Environment")
@@ -214,10 +265,10 @@ def _android_pictures_folder() -> str:
 
 @lru_cache(maxsize=1)
 def _android_videos_folder() -> str:
-    """:return: videos folder for the Android OS"""
+    """:returns: videos folder for the Android OS"""
     # Get directories with pyjnius
     try:
-        from jnius import autoclass  # noqa: PLC0415
+        from jnius import autoclass  # noqa: PLC0415  # ty: ignore[unresolved-import]
 
         context = autoclass("android.content.Context")
         environment = autoclass("android.os.Environment")
@@ -230,10 +281,10 @@ def _android_videos_folder() -> str:
 
 @lru_cache(maxsize=1)
 def _android_music_folder() -> str:
-    """:return: music folder for the Android OS"""
+    """:returns: music folder for the Android OS"""
     # Get directories with pyjnius
     try:
-        from jnius import autoclass  # noqa: PLC0415
+        from jnius import autoclass  # noqa: PLC0415  # ty: ignore[unresolved-import]
 
         context = autoclass("android.content.Context")
         environment = autoclass("android.os.Environment")