NEWS.rst

@@ -1,3 +1,13 @@
+v25.0.0
+=======
+
+Deprecations and Removals
+-------------------------
+
+- Removed check for config in XDG_DATA_HOME on Linux systems. (#99)
+- In platform config support, remove support for Windows XP, now 10 years sunset.
+
+
 v24.3.1
 =======
 

conftest.py

@@ -1,21 +1,8 @@
-import ctypes
+import platform
 
-collect_ignore = ["hook-keyring.backend.py"]
 
+not_macOS = platform.system() != 'Darwin'
 
-def macos_api_ignore():
-    """
-    Starting with macOS 11, the security API becomes
-    non-viable except on universal2 binaries.
-
-    Ref #525.
-    """
-
-    try:
-        ctypes.CDLL(ctypes.util.find_library('Security')).SecItemAdd
-        return False
-    except Exception:
-        return True
-
-
-collect_ignore.extend(['keyring/backends/macOS/api.py'] * macos_api_ignore())
+collect_ignore = ["hook-keyring.backend.py"] + [
+    'keyring/backends/macOS/api.py'
+] * not_macOS

hook-keyring.backend.py

@@ -2,6 +2,6 @@
 Hook used by pyinstaller to expose hidden imports.
 """
 
-from keyring.py312compat import metadata
+from keyring.compat.py312 import metadata
 
 hiddenimports = [ep.value for ep in metadata.entry_points(group='keyring.backends')]

keyring/__init__.py

@@ -1,10 +1,10 @@
 from .core import (
-    set_keyring,
-    get_keyring,
-    set_password,
-    get_password,
     delete_password,
     get_credential,
+    get_keyring,
+    get_password,
+    set_keyring,
+    set_password,
 )
 
 __all__ = (

keyring/backend.py

@@ -4,23 +4,24 @@
 
 from __future__ import annotations
 
-import os
 import abc
+import copy
 import logging
 import operator
-import copy
-
+import os
 import typing
 
-from .py312compat import metadata
+from jaraco.functools import once
+
 from . import credentials, errors, util
-from ._compat import properties
+from .compat import properties
+from .compat.py312 import metadata
 
 log = logging.getLogger(__name__)
 
 
 by_priority = operator.attrgetter('priority')
-_limit: typing.Optional[typing.Callable[[KeyringBackend], bool]] = None
+_limit: typing.Callable[[KeyringBackend], bool] | None = None
 
 
 class KeyringBackendMeta(abc.ABCMeta):
@@ -67,13 +68,13 @@ def priority(self) -> float:
     @properties.classproperty
     def viable(cls):
         with errors.ExceptionRaisedContext() as exc:
-            cls.priority
+            cls.priority  # noqa: B018
         return not exc
 
     @classmethod
     def get_viable_backends(
-        cls: typing.Type[KeyringBackend],
-    ) -> filter[typing.Type[KeyringBackend]]:
+        cls: type[KeyringBackend],
+    ) -> filter[type[KeyringBackend]]:
         """
         Return all subclasses deemed viable.
         """
@@ -92,12 +93,10 @@ def name(cls) -> str:
 
     def __str__(self) -> str:
         keyring_class = type(self)
-        return "{}.{} (priority: {:g})".format(
-            keyring_class.__module__, keyring_class.__name__, keyring_class.priority
-        )
+        return f"{keyring_class.__module__}.{keyring_class.__name__} (priority: {keyring_class.priority:g})"
 
     @abc.abstractmethod
-    def get_password(self, service: str, username: str) -> typing.Optional[str]:
+    def get_password(self, service: str, username: str) -> str | None:
         """Get password of the username for the service"""
         return None
 
@@ -127,8 +126,8 @@ def delete_password(self, service: str, username: str) -> None:
     def get_credential(
         self,
         service: str,
-        username: typing.Optional[str],
-    ) -> typing.Optional[credentials.Credential]:
+        username: str | None,
+    ) -> credentials.Credential | None:
         """Gets the username and password for the service.
         Returns a Credential instance.
 
@@ -146,14 +145,12 @@ def get_credential(
     def set_properties_from_env(self) -> None:
         """For all KEYRING_PROPERTY_* env var, set that property."""
 
-        def parse(item: typing.Tuple[str, str]):
+        def parse(item: tuple[str, str]):
             key, value = item
             pre, sep, name = key.partition('KEYRING_PROPERTY_')
             return sep and (name.lower(), value)
 
-        props: filter[typing.Tuple[str, str]] = filter(
-            None, map(parse, os.environ.items())
-        )
+        props: filter[tuple[str, str]] = filter(None, map(parse, os.environ.items()))
         for name, value in props:
             setattr(self, name, value)
 
@@ -213,8 +210,8 @@ def _load_plugins() -> None:
             log.exception(f"Error initializing plugin {ep}.")
 
 
-@util.once
-def get_all_keyring() -> typing.List[KeyringBackend]:
+@once
+def get_all_keyring() -> list[KeyringBackend]:
     """
     Return a list of all implemented keyrings that can be constructed without
     parameters.
@@ -249,8 +246,8 @@ class SchemeSelectable:
     )
 
     def _query(
-        self, service: str, username: typing.Optional[str] = None, **base: typing.Any
-    ) -> typing.Dict[str, str]:
+        self, service: str, username: str | None = None, **base: typing.Any
+    ) -> dict[str, str]:
         scheme = self.schemes[self.scheme]
         return dict(
             {

keyring/backends/SecretService.py

@@ -1,15 +1,15 @@
-from contextlib import closing
 import logging
+from contextlib import closing
 
 from .. import backend
-from .._compat import properties
 from ..backend import KeyringBackend
+from ..compat import properties
 from ..credentials import SimpleCredential
 from ..errors import (
-    InitError,
-    PasswordDeleteError,
     ExceptionRaisedContext,
+    InitError,
     KeyringLocked,
+    PasswordDeleteError,
 )
 
 try:
@@ -32,7 +32,7 @@ class Keyring(backend.SchemeSelectable, KeyringBackend):
     @properties.classproperty
     def priority(cls) -> float:
         with ExceptionRaisedContext() as exc:
-            secretstorage.__name__
+            secretstorage.__name__  # noqa: B018
         if exc:
             raise RuntimeError("SecretStorage required")
         if secretstorage.__version_tuple__ < (3, 2):
@@ -45,7 +45,7 @@ def priority(cls) -> float:
                         "activatable through D-Bus"
                     )
         except exceptions.SecretStorageException as e:
-            raise RuntimeError("Unable to initialize SecretService: %s" % e)
+            raise RuntimeError(f"Unable to initialize SecretService: {e}") from e
         return 5
 
     def get_preferred_collection(self):
@@ -60,7 +60,7 @@ def get_preferred_collection(self):
             else:
                 collection = secretstorage.get_default_collection(bus)
         except exceptions.SecretStorageException as e:
-            raise InitError("Failed to create the collection: %s." % e)
+            raise InitError(f"Failed to create the collection: {e}.") from e
         if collection.is_locked():
             collection.unlock()
             if collection.is_locked():  # User dismissed the prompt
@@ -86,7 +86,7 @@ def set_password(self, service, username, password):
         """Set password for the username of the service"""
         collection = self.get_preferred_collection()
         attributes = self._query(service, username, application=self.appid)
-        label = "Password for '{}' on '{}'".format(username, service)
+        label = f"Password for '{username}' on '{service}'"
         with closing(collection.connection):
             collection.create_item(label, attributes, password, replace=True)
 

keyring/backends/Windows.py

@@ -1,26 +1,24 @@
 import logging
 
-from .._compat import properties
 from ..backend import KeyringBackend
+from ..compat import properties
 from ..credentials import SimpleCredential
-from ..errors import PasswordDeleteError, ExceptionRaisedContext
-
+from ..errors import ExceptionRaisedContext, PasswordDeleteError
 
 with ExceptionRaisedContext() as missing_deps:
     try:
         # prefer pywin32-ctypes
-        from win32ctypes.pywin32 import pywintypes
-        from win32ctypes.pywin32 import win32cred
+        from win32ctypes.pywin32 import pywintypes, win32cred
 
         # force demand import to raise ImportError
-        win32cred.__name__
+        win32cred.__name__  # noqa: B018
     except ImportError:
         # fallback to pywin32
         import pywintypes
         import win32cred
 
         # force demand import to raise ImportError
-        win32cred.__name__
+        win32cred.__name__  # noqa: B018
 
 log = logging.getLogger(__name__)
 
@@ -39,7 +37,7 @@ def __set__(self, keyring, value):
         if isinstance(value, str):
             attr = 'CRED_PERSIST_' + value.replace(' ', '_').upper()
             value = getattr(win32cred, attr)
-        setattr(keyring, '_persist', value)
+        keyring._persist = value
 
 
 class DecodingCredential(dict):

keyring/backends/chainer.py

@@ -4,7 +4,7 @@
 """
 
 from .. import backend
-from .._compat import properties
+from ..compat import properties
 from . import fail
 
 

keyring/backends/fail.py

@@ -1,5 +1,5 @@
 from ..backend import KeyringBackend
-from .._compat import properties
+from ..compat import properties
 from ..errors import NoKeyringError
 
 

keyring/backends/kwallet.py

@@ -1,12 +1,11 @@
-import sys
-import os
 import contextlib
+import os
+import sys
 
 from ..backend import KeyringBackend
+from ..compat import properties
 from ..credentials import SimpleCredential
-from ..errors import PasswordDeleteError
-from ..errors import PasswordSetError, InitError, KeyringLocked
-from .._compat import properties
+from ..errors import InitError, KeyringLocked, PasswordDeleteError, PasswordSetError
 
 try:
     import dbus
@@ -44,7 +43,7 @@ def priority(cls) -> float:
         try:
             bus = dbus.SessionBus(mainloop=DBusGMainLoop())
         except dbus.DBusException as exc:
-            raise RuntimeError(exc.get_dbus_message())
+            raise RuntimeError(exc.get_dbus_message()) from exc
         if not (
             bus.name_has_owner(cls.bus_name)
             or cls.bus_name in bus.list_activatable_names()
@@ -97,7 +96,7 @@ def connected(self, service):
             self.iface = dbus.Interface(remote_obj, 'org.kde.KWallet')
             self.handle = self.iface.open(self.iface.networkWallet(), wId, self.appid)
         except dbus.DBusException as e:
-            raise InitError('Failed to open keyring: %s.' % e)
+            raise InitError(f'Failed to open keyring: {e}.') from e
 
         if self.handle < 0:
             return False

keyring/backends/libsecret.py

@@ -1,20 +1,19 @@
 import logging
 
 from .. import backend
-from .._compat import properties
 from ..backend import KeyringBackend
+from ..compat import properties
 from ..credentials import SimpleCredential
 from ..errors import (
+    KeyringLocked,
     PasswordDeleteError,
     PasswordSetError,
-    KeyringLocked,
 )
 
 available = False
 try:
     import gi
-    from gi.repository import Gio
-    from gi.repository import GLib
+    from gi.repository import Gio, GLib
 
     gi.require_version('Secret', '1')
     from gi.repository import Secret
@@ -84,7 +83,7 @@ def get_password(self, service, username):
     def set_password(self, service, username, password):
         """Set password for the username of the service"""
         attributes = self._query(service, username, application=self.appid)
-        label = "Password for '{}' on '{}'".format(username, service)
+        label = f"Password for '{username}' on '{service}'"
         try:
             stored = Secret.password_store_sync(
                 self.schema, attributes, self.collection, label, password, None