android-notify 1.60.0__py3-none-any.whl → 1.60.1__py3-none-any.whl

venv/Lib/site-packages/keyring/backend.py

@@ -1,300 +0,0 @@
-"""
-Keyring implementation support
-"""
-
-from __future__ import annotations
-
-import abc
-import copy
-import functools
-import logging
-import operator
-import os
-import typing
-import warnings
-
-from jaraco.context import ExceptionTrap
-from jaraco.functools import once
-
-from . import credentials, errors, util
-from .compat import properties
-from .compat.py312 import metadata
-
-log = logging.getLogger(__name__)
-
-
-by_priority = operator.attrgetter('priority')
-_limit: typing.Callable[[KeyringBackend], bool] | None = None
-
-
-class KeyringBackendMeta(abc.ABCMeta):
-    """
-    Specialized subclass behavior.
-
-    Keeps a registry of all (non-abstract) types.
-
-    Wraps set_password to validate the username.
-    """
-
-    def __init__(cls, name, bases, dict):
-        super().__init__(name, bases, dict)
-        cls._register()
-        cls._validate_username_in_set_password()
-
-    def _register(cls):
-        if not hasattr(cls, '_classes'):
-            cls._classes = set()
-        classes = cls._classes
-        if not cls.__abstractmethods__:
-            classes.add(cls)
-
-    def _validate_username_in_set_password(cls):
-        """
-        Wrap ``set_password`` such to validate the passed username.
-        """
-        orig = cls.set_password
-
-        @functools.wraps(orig)
-        def wrapper(self, system, username, *args, **kwargs):
-            self._validate_username(username)
-            return orig(self, system, username, *args, **kwargs)
-
-        cls.set_password = wrapper
-
-
-class KeyringBackend(metaclass=KeyringBackendMeta):
-    """The abstract base class of the keyring, every backend must implement
-    this interface.
-    """
-
-    def __init__(self):
-        self.set_properties_from_env()
-
-    @properties.classproperty
-    def priority(self) -> float:
-        """
-        Each backend class must supply a priority, a number (float or integer)
-        indicating the priority of the backend relative to all other backends.
-        The priority need not be static -- it may (and should) vary based
-        attributes of the environment in which is runs (platform, available
-        packages, etc.).
-
-        A higher number indicates a higher priority. The priority should raise
-        a RuntimeError with a message indicating the underlying cause if the
-        backend is not suitable for the current environment.
-
-        As a rule of thumb, a priority between zero but less than one is
-        suitable, but a priority of one or greater is recommended.
-        """
-        raise NotImplementedError
-
-    # Python 3.8 compatibility
-    passes = ExceptionTrap().passes
-
-    @properties.classproperty
-    @passes
-    def viable(cls):
-        cls.priority  # noqa: B018
-
-    @classmethod
-    def get_viable_backends(
-        cls: type[KeyringBackend],
-    ) -> filter[type[KeyringBackend]]:
-        """
-        Return all subclasses deemed viable.
-        """
-        return filter(operator.attrgetter('viable'), cls._classes)
-
-    @properties.classproperty
-    def name(cls) -> str:
-        """
-        The keyring name, suitable for display.
-
-        The name is derived from module and class name.
-        """
-        parent, sep, mod_name = cls.__module__.rpartition('.')
-        mod_name = mod_name.replace('_', ' ')
-        # mypy doesn't see `cls` is `type[Self]`, might be fixable in jaraco.classes
-        return ' '.join([mod_name, cls.__name__])  # type: ignore[attr-defined]
-
-    def __str__(self) -> str:
-        keyring_class = type(self)
-        return f"{keyring_class.__module__}.{keyring_class.__name__} (priority: {keyring_class.priority:g})"
-
-    @abc.abstractmethod
-    def get_password(self, service: str, username: str) -> str | None:
-        """Get password of the username for the service"""
-        return None
-
-    def _validate_username(self, username: str) -> None:
-        """
-        Ensure the username is not empty.
-        """
-        if not username:
-            warnings.warn(
-                "Empty usernames are deprecated. See #668",
-                DeprecationWarning,
-                stacklevel=3,
-            )
-            # raise ValueError("Username cannot be empty")
-
-    @abc.abstractmethod
-    def set_password(self, service: str, username: str, password: str) -> None:
-        """Set password for the username of the service.
-
-        If the backend cannot store passwords, raise
-        PasswordSetError.
-        """
-        raise errors.PasswordSetError("reason")
-
-    # for backward-compatibility, don't require a backend to implement
-    #  delete_password
-    # @abc.abstractmethod
-    def delete_password(self, service: str, username: str) -> None:
-        """Delete the password for the username of the service.
-
-        If the backend cannot delete passwords, raise
-        PasswordDeleteError.
-        """
-        raise errors.PasswordDeleteError("reason")
-
-    # for backward-compatibility, don't require a backend to implement
-    #  get_credential
-    # @abc.abstractmethod
-    def get_credential(
-        self,
-        service: str,
-        username: str | None,
-    ) -> credentials.Credential | None:
-        """Gets the username and password for the service.
-        Returns a Credential instance.
-
-        The *username* argument is optional and may be omitted by
-        the caller or ignored by the backend. Callers must use the
-        returned username.
-        """
-        # The default implementation requires a username here.
-        if username is not None:
-            password = self.get_password(service, username)
-            if password is not None:
-                return credentials.SimpleCredential(username, password)
-        return None
-
-    def set_properties_from_env(self) -> None:
-        """For all KEYRING_PROPERTY_* env var, set that property."""
-
-        def parse(item: tuple[str, str]):
-            key, value = item
-            pre, sep, name = key.partition('KEYRING_PROPERTY_')
-            return sep and (name.lower(), value)
-
-        props: filter[tuple[str, str]] = filter(None, map(parse, os.environ.items()))
-        for name, value in props:
-            setattr(self, name, value)
-
-    def with_properties(self, **kwargs: typing.Any) -> KeyringBackend:
-        alt = copy.copy(self)
-        vars(alt).update(kwargs)
-        return alt
-
-
-class Crypter:
-    """Base class providing encryption and decryption"""
-
-    @abc.abstractmethod
-    def encrypt(self, value):
-        """Encrypt the value."""
-        pass
-
-    @abc.abstractmethod
-    def decrypt(self, value):
-        """Decrypt the value."""
-        pass
-
-
-class NullCrypter(Crypter):
-    """A crypter that does nothing"""
-
-    def encrypt(self, value):
-        return value
-
-    def decrypt(self, value):
-        return value
-
-
-def _load_plugins() -> None:
-    """
-    Locate all setuptools entry points by the name 'keyring backends'
-    and initialize them.
-    Any third-party library may register an entry point by adding the
-    following to their setup.cfg::
-
-        [options.entry_points]
-        keyring.backends =
-            plugin_name = mylib.mymodule:initialize_func
-
-    `plugin_name` can be anything, and is only used to display the name
-    of the plugin at initialization time.
-
-    `initialize_func` is optional, but will be invoked if callable.
-    """
-    for ep in metadata.entry_points(group='keyring.backends'):
-        try:
-            log.debug('Loading %s', ep.name)
-            init_func = ep.load()
-            if callable(init_func):
-                init_func()
-        except Exception:
-            log.exception(f"Error initializing plugin {ep}.")
-
-
-@once
-def get_all_keyring() -> list[KeyringBackend]:
-    """
-    Return a list of all implemented keyrings that can be constructed without
-    parameters.
-    """
-    _load_plugins()
-    viable_classes = KeyringBackend.get_viable_backends()
-    rings = util.suppress_exceptions(viable_classes, exceptions=TypeError)
-    return list(rings)
-
-
-class SchemeSelectable:
-    """
-    Allow a backend to select different "schemes" for the
-    username and service.
-
-    >>> backend = SchemeSelectable()
-    >>> backend._query('contoso', 'alice')
-    {'username': 'alice', 'service': 'contoso'}
-    >>> backend._query('contoso')
-    {'service': 'contoso'}
-    >>> backend.scheme = 'KeePassXC'
-    >>> backend._query('contoso', 'alice')
-    {'UserName': 'alice', 'Title': 'contoso'}
-    >>> backend._query('contoso', 'alice', foo='bar')
-    {'UserName': 'alice', 'Title': 'contoso', 'foo': 'bar'}
-    """
-
-    scheme = 'default'
-    schemes = dict(
-        default=dict(username='username', service='service'),
-        KeePassXC=dict(username='UserName', service='Title'),
-    )
-
-    def _query(
-        self, service: str, username: str | None = None, **base: typing.Any
-    ) -> dict[str, str]:
-        scheme = self.schemes[self.scheme]
-        return dict(
-            {
-                scheme['username']: username,
-                scheme['service']: service,
-            }
-            if username is not None
-            else {
-                scheme['service']: service,
-            },
-            **base,
-        )

venv/Lib/site-packages/keyring/backends/SecretService.py

@@ -1,120 +0,0 @@
-import logging
-from contextlib import closing
-
-from jaraco.context import ExceptionTrap
-
-from .. import backend
-from ..backend import KeyringBackend
-from ..compat import properties
-from ..credentials import SimpleCredential
-from ..errors import (
-    InitError,
-    KeyringLocked,
-    PasswordDeleteError,
-)
-
-try:
-    import secretstorage
-    import secretstorage.exceptions as exceptions
-except ImportError:
-    pass
-except AttributeError:
-    # See https://github.com/jaraco/keyring/issues/296
-    pass
-
-log = logging.getLogger(__name__)
-
-
-class Keyring(backend.SchemeSelectable, KeyringBackend):
-    """Secret Service Keyring"""
-
-    appid = 'Python keyring library'
-
-    @properties.classproperty
-    def priority(cls) -> float:
-        with ExceptionTrap() as exc:
-            secretstorage.__name__  # noqa: B018
-        if exc:
-            raise RuntimeError("SecretStorage required")
-        if secretstorage.__version_tuple__ < (3, 2):
-            raise RuntimeError("SecretStorage 3.2 or newer required")
-        try:
-            with closing(secretstorage.dbus_init()) as connection:
-                if not secretstorage.check_service_availability(connection):
-                    raise RuntimeError(
-                        "The Secret Service daemon is neither running nor "
-                        "activatable through D-Bus"
-                    )
-        except exceptions.SecretStorageException as e:
-            raise RuntimeError(f"Unable to initialize SecretService: {e}") from e
-        return 5
-
-    def get_preferred_collection(self):
-        """If self.preferred_collection contains a D-Bus path,
-        the collection at that address is returned. Otherwise,
-        the default collection is returned.
-        """
-        bus = secretstorage.dbus_init()
-        try:
-            if hasattr(self, 'preferred_collection'):
-                collection = secretstorage.Collection(bus, self.preferred_collection)
-            else:
-                collection = secretstorage.get_default_collection(bus)
-        except exceptions.SecretStorageException as 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
-                raise KeyringLocked("Failed to unlock the collection!")
-        return collection
-
-    def unlock(self, item):
-        if hasattr(item, 'unlock'):
-            item.unlock()
-        if item.is_locked():  # User dismissed the prompt
-            raise KeyringLocked('Failed to unlock the item!')
-
-    def get_password(self, service, username):
-        """Get password of the username for the service"""
-        collection = self.get_preferred_collection()
-        with closing(collection.connection):
-            items = collection.search_items(self._query(service, username))
-            for item in items:
-                self.unlock(item)
-                return item.get_secret().decode('utf-8')
-
-    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 = f"Password for '{username}' on '{service}'"
-        with closing(collection.connection):
-            collection.create_item(label, attributes, password, replace=True)
-
-    def delete_password(self, service, username):
-        """Delete the stored password (only the first one)"""
-        collection = self.get_preferred_collection()
-        with closing(collection.connection):
-            items = collection.search_items(self._query(service, username))
-            for item in items:
-                return item.delete()
-        raise PasswordDeleteError("No such password!")
-
-    def get_credential(self, service, username):
-        """Gets the first username and password for a service.
-        Returns a Credential instance
-
-        The username can be omitted, but if there is one, it will use get_password
-        and return a SimpleCredential containing  the username and password
-        Otherwise, it will return the first username and password combo that it finds.
-        """
-        scheme = self.schemes[self.scheme]
-        query = self._query(service, username)
-        collection = self.get_preferred_collection()
-
-        with closing(collection.connection):
-            items = collection.search_items(query)
-            for item in items:
-                self.unlock(item)
-                username = item.get_attributes().get(scheme['username'])
-                return SimpleCredential(username, item.get_secret().decode('utf-8'))

venv/Lib/site-packages/keyring/backends/Windows.py

@@ -1,168 +0,0 @@
-from __future__ import annotations
-
-import logging
-
-from jaraco.context import ExceptionTrap
-
-from ..backend import KeyringBackend
-from ..compat import properties
-from ..credentials import SimpleCredential
-from ..errors import PasswordDeleteError
-
-with ExceptionTrap() as missing_deps:
-    try:
-        # prefer pywin32-ctypes
-        from win32ctypes.pywin32 import pywintypes, win32cred
-
-        # force demand import to raise ImportError
-        win32cred.__name__  # noqa: B018
-    except ImportError:
-        # fallback to pywin32
-        import pywintypes
-        import win32cred
-
-        # force demand import to raise ImportError
-        win32cred.__name__  # noqa: B018
-
-log = logging.getLogger(__name__)
-
-
-class Persistence:
-    def __get__(self, keyring, type=None):
-        return getattr(keyring, '_persist', win32cred.CRED_PERSIST_ENTERPRISE)
-
-    def __set__(self, keyring, value):
-        """
-        Set the persistence value on the Keyring. Value may be
-        one of the win32cred.CRED_PERSIST_* constants or a
-        string representing one of those constants. For example,
-        'local machine' or 'session'.
-        """
-        if isinstance(value, str):
-            attr = 'CRED_PERSIST_' + value.replace(' ', '_').upper()
-            value = getattr(win32cred, attr)
-        keyring._persist = value
-
-
-class DecodingCredential(dict):
-    @property
-    def value(self):
-        """
-        Attempt to decode the credential blob as UTF-16 then UTF-8.
-        """
-        cred = self['CredentialBlob']
-        try:
-            return cred.decode('utf-16')
-        except UnicodeDecodeError:
-            decoded_cred_utf8 = cred.decode('utf-8')
-            log.warning(
-                "Retrieved a UTF-8 encoded credential. Please be aware that "
-                "this library only writes credentials in UTF-16."
-            )
-            return decoded_cred_utf8
-
-
-class WinVaultKeyring(KeyringBackend):
-    """
-    WinVaultKeyring stores encrypted passwords using the Windows Credential
-    Manager.
-
-    Requires pywin32
-
-    This backend does some gymnastics to simulate multi-user support,
-    which WinVault doesn't support natively. See
-    https://github.com/jaraco/keyring/issues/47#issuecomment-75763152
-    for details on the implementation, but here's the gist:
-
-    Passwords are stored under the service name unless there is a collision
-    (another password with the same service name but different user name),
-    in which case the previous password is moved into a compound name:
-    {username}@{service}
-    """
-
-    persist = Persistence()
-
-    @properties.classproperty
-    def priority(cls) -> float:
-        """
-        If available, the preferred backend on Windows.
-        """
-        if missing_deps:
-            raise RuntimeError("Requires Windows and pywin32")
-        return 5
-
-    @staticmethod
-    def _compound_name(username, service):
-        return f'{username}@{service}'
-
-    def get_password(self, service, username):
-        res = self._resolve_credential(service, username)
-        return res and res.value
-
-    def _resolve_credential(
-        self, service: str, username: str | None
-    ) -> DecodingCredential | None:
-        # first attempt to get the password under the service name
-        res = self._read_credential(service)
-        if not res or username and res['UserName'] != username:
-            # It wasn't found so attempt to get it with the compound name
-            res = self._read_credential(self._compound_name(username, service))
-        return res
-
-    def _read_credential(self, target):
-        try:
-            res = win32cred.CredRead(
-                Type=win32cred.CRED_TYPE_GENERIC, TargetName=target
-            )
-        except pywintypes.error as e:
-            if e.winerror == 1168 and e.funcname == 'CredRead':  # not found
-                return None
-            raise
-        return DecodingCredential(res)
-
-    def set_password(self, service, username, password):
-        existing_pw = self._read_credential(service)
-        if existing_pw:
-            # resave the existing password using a compound target
-            existing_username = existing_pw['UserName']
-            target = self._compound_name(existing_username, service)
-            self._set_password(
-                target,
-                existing_username,
-                existing_pw.value,
-            )
-        self._set_password(service, username, str(password))
-
-    def _set_password(self, target, username, password):
-        credential = dict(
-            Type=win32cred.CRED_TYPE_GENERIC,
-            TargetName=target,
-            UserName=username,
-            CredentialBlob=password,
-            Comment="Stored using python-keyring",
-            Persist=self.persist,
-        )
-        win32cred.CredWrite(credential, 0)
-
-    def delete_password(self, service, username):
-        compound = self._compound_name(username, service)
-        deleted = False
-        for target in service, compound:
-            existing_pw = self._read_credential(target)
-            if existing_pw and existing_pw['UserName'] == username:
-                deleted = True
-                self._delete_password(target)
-        if not deleted:
-            raise PasswordDeleteError(service)
-
-    def _delete_password(self, target):
-        try:
-            win32cred.CredDelete(Type=win32cred.CRED_TYPE_GENERIC, TargetName=target)
-        except pywintypes.error as e:
-            if e.winerror == 1168 and e.funcname == 'CredDelete':  # not found
-                return
-            raise
-
-    def get_credential(self, service, username):
-        res = self._resolve_credential(service, username)
-        return res and SimpleCredential(res['UserName'], res.value)

venv/Lib/site-packages/keyring/backends/chainer.py

@@ -1,71 +0,0 @@
-"""
-Keyring Chainer - iterates over other viable backends to
-discover passwords in each.
-"""
-
-from .. import backend
-from ..compat import properties
-from . import fail
-
-
-class ChainerBackend(backend.KeyringBackend):
-    """
-    >>> ChainerBackend()
-    <keyring.backends.chainer.ChainerBackend object at ...>
-    """
-
-    # override viability as 'priority' cannot be determined
-    # until other backends have been constructed
-    viable = True
-
-    @properties.classproperty
-    def priority(cls) -> float:
-        """
-        If there are backends to chain, high priority
-        Otherwise very low priority since our operation when empty
-        is the same as null.
-        """
-        return 10 if len(cls.backends) > 1 else (fail.Keyring.priority - 1)
-
-    @properties.classproperty
-    def backends(cls):
-        """
-        Discover all keyrings for chaining.
-        """
-
-        def allow(keyring):
-            limit = backend._limit or bool
-            return (
-                not isinstance(keyring, ChainerBackend)
-                and limit(keyring)
-                and keyring.priority > 0
-            )
-
-        allowed = filter(allow, backend.get_all_keyring())
-        return sorted(allowed, key=backend.by_priority, reverse=True)
-
-    def get_password(self, service, username):
-        for keyring in self.backends:
-            password = keyring.get_password(service, username)
-            if password is not None:
-                return password
-
-    def set_password(self, service, username, password):
-        for keyring in self.backends:
-            try:
-                return keyring.set_password(service, username, password)
-            except NotImplementedError:
-                pass
-
-    def delete_password(self, service, username):
-        for keyring in self.backends:
-            try:
-                return keyring.delete_password(service, username)
-            except NotImplementedError:
-                pass
-
-    def get_credential(self, service, username):
-        for keyring in self.backends:
-            credential = keyring.get_credential(service, username)
-            if credential is not None:
-                return credential

venv/Lib/site-packages/keyring/backends/fail.py

@@ -1,30 +0,0 @@
-from ..backend import KeyringBackend
-from ..compat import properties
-from ..errors import NoKeyringError
-
-
-class Keyring(KeyringBackend):
-    """
-    Keyring that raises error on every operation.
-
-    >>> kr = Keyring()
-    >>> kr.get_password('svc', 'user')
-    Traceback (most recent call last):
-    ...
-    keyring.errors.NoKeyringError: ...No recommended backend...
-    """
-
-    @properties.classproperty
-    def priority(cls) -> float:
-        return 0
-
-    def get_password(self, service, username, password=None):
-        msg = (
-            "No recommended backend was available. Install a recommended 3rd "
-            "party backend package; or, install the keyrings.alt package if "
-            "you want to use the non-recommended backends. See "
-            "https://pypi.org/project/keyring for details."
-        )
-        raise NoKeyringError(msg)
-
-    set_password = delete_password = get_password