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

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

@@ -0,0 +1,220 @@
+"""Simple command line interface to get/set password from a keyring"""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import json
+import sys
+
+from . import (
+    backend,
+    completion,
+    core,
+    credentials,
+    delete_password,
+    get_credential,
+    get_password,
+    set_keyring,
+    set_password,
+)
+from .util import platform_
+
+
+class CommandLineTool:
+    # Attributes set dynamically by the ArgumentParser
+    keyring_path: str | None
+    keyring_backend: str | None
+    get_mode: str
+    output_format: str
+    operation: str
+    service: str
+    username: str
+
+    def __init__(self):
+        self.parser = argparse.ArgumentParser()
+        self.parser.add_argument(
+            "-p",
+            "--keyring-path",
+            dest="keyring_path",
+            default=None,
+            help="Path to the keyring backend",
+        )
+        self.parser.add_argument(
+            "-b",
+            "--keyring-backend",
+            dest="keyring_backend",
+            default=None,
+            help="Name of the keyring backend",
+        )
+        self.parser.add_argument(
+            "--list-backends",
+            action="store_true",
+            help="List keyring backends and exit",
+        )
+        self.parser.add_argument(
+            "--disable", action="store_true", help="Disable keyring and exit"
+        )
+        self.parser._get_modes = ["password", "creds"]
+        self.parser.add_argument(
+            "--mode",
+            choices=self.parser._get_modes,
+            dest="get_mode",
+            default="password",
+            help="""
+            Mode for 'get' operation.
+            'password' requires a username and will return only the password.
+            'creds' does not require a username and will return both the username and password separated by a newline.
+
+            Default is 'password'
+            """,
+        )
+        self.parser._output_formats = ["plain", "json"]
+        self.parser.add_argument(
+            "--output",
+            choices=self.parser._output_formats,
+            dest="output_format",
+            default="plain",
+            help="""
+            Output format for 'get' operation.
+
+            Default is 'plain'
+            """,
+        )
+        self.parser._operations = ["get", "set", "del", "diagnose"]
+        self.parser.add_argument(
+            'operation',
+            choices=self.parser._operations,
+            nargs="?",
+        )
+        self.parser.add_argument(
+            'service',
+            nargs="?",
+        )
+        self.parser.add_argument(
+            'username',
+            nargs="?",
+        )
+        completion.install(self.parser)
+
+    def run(self, argv):
+        args = self.parser.parse_args(argv)
+        vars(self).update(vars(args))
+
+        if args.list_backends:
+            for k in backend.get_all_keyring():
+                print(k)
+            return
+
+        if args.disable:
+            core.disable()
+            return
+
+        if args.operation == 'diagnose':
+            self.diagnose()
+            return
+
+        self._check_args()
+        self._load_spec_backend()
+        method = getattr(self, f'do_{self.operation}', self.invalid_op)
+        return method()
+
+    def _check_args(self):
+        needs_username = self.operation != 'get' or self.get_mode != 'creds'
+        required = (['service'] + ['username'] * needs_username) * bool(self.operation)
+        if any(getattr(self, param) is None for param in required):
+            self.parser.error(f"{self.operation} requires {' and '.join(required)}")
+
+    def do_get(self):
+        credential = getattr(self, f'_get_{self.get_mode}')()
+        if credential is None:
+            raise SystemExit(1)
+        getattr(self, f'_emit_{self.output_format}')(credential)
+
+    def _emit_json(self, credential: credentials.Credential):
+        print(json.dumps(credential._vars()))
+
+    def _emit_plain(self, credential: credentials.Credential):
+        for val in credential._vars().values():
+            print(val)
+
+    def _get_creds(self) -> credentials.Credential | None:
+        return get_credential(self.service, self.username)
+
+    def _get_password(self) -> credentials.Credential | None:
+        password = get_password(self.service, self.username)
+        return (
+            credentials.AnonymousCredential(password) if password is not None else None
+        )
+
+    def do_set(self):
+        password = self.input_password(
+            f"Password for '{self.username}' in '{self.service}': "
+        )
+        set_password(self.service, self.username, password)
+
+    def do_del(self):
+        delete_password(self.service, self.username)
+
+    def diagnose(self):
+        config_root = core._config_path()
+        if config_root.exists():
+            print("config path:", config_root)
+        else:
+            print("config path:", config_root, "(absent)")
+        print("data root:", platform_.data_root())
+
+    def invalid_op(self):
+        self.parser.error(f"Specify operation ({', '.join(self.parser._operations)}).")
+
+    def _load_spec_backend(self):
+        if self.keyring_backend is None:
+            return
+
+        try:
+            if self.keyring_path:
+                sys.path.insert(0, self.keyring_path)
+            set_keyring(core.load_keyring(self.keyring_backend))
+        except Exception as exc:
+            # Tons of things can go wrong here:
+            #   ImportError when using "fjkljfljkl"
+            #   AttributeError when using "os.path.bar"
+            #   TypeError when using "__builtins__.str"
+            # So, we play on the safe side, and catch everything.
+            self.parser.error(f"Unable to load specified keyring: {exc}")
+
+    def input_password(self, prompt):
+        """Retrieve password from input."""
+        return self.pass_from_pipe() or getpass.getpass(prompt)
+
+    @classmethod
+    def pass_from_pipe(cls):
+        """Return password from pipe if not on TTY, else False."""
+        is_pipe = not sys.stdin.isatty()
+        return is_pipe and cls.strip_last_newline(sys.stdin.read())
+
+    @staticmethod
+    def strip_last_newline(str):
+        r"""Strip one last newline, if present.
+
+        >>> CommandLineTool.strip_last_newline('foo')
+        'foo'
+        >>> CommandLineTool.strip_last_newline('foo\n')
+        'foo'
+        """
+        slc = slice(-1 if str.endswith('\n') else None)
+        return str[slc]
+
+
+def main(argv=None):
+    """Main command line interface."""
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    cli = CommandLineTool()
+    return cli.run(argv)
+
+
+if __name__ == '__main__':
+    sys.exit(main())

venv/Lib/site-packages/keyring/compat/__init__.py

@@ -0,0 +1,7 @@
+__all__ = ['properties']
+
+
+try:
+    from jaraco.classes import properties
+except ImportError:  # pragma: no cover
+    from . import properties  # type: ignore[no-redef]

venv/Lib/site-packages/keyring/compat/properties.py

@@ -0,0 +1,169 @@
+# from jaraco.classes 3.2.2
+
+
+class NonDataProperty:
+    """Much like the property builtin, but only implements __get__,
+    making it a non-data property, and can be subsequently reset.
+
+    See http://users.rcn.com/python/download/Descriptor.htm for more
+    information.
+
+    >>> class X(object):
+    ...   @NonDataProperty
+    ...   def foo(self):
+    ...     return 3
+    >>> x = X()
+    >>> x.foo
+    3
+    >>> x.foo = 4
+    >>> x.foo
+    4
+    """
+
+    def __init__(self, fget):
+        assert fget is not None, "fget cannot be none"
+        assert callable(fget), "fget must be callable"
+        self.fget = fget
+
+    def __get__(self, obj, objtype=None):
+        if obj is None:
+            return self
+        return self.fget(obj)
+
+
+class classproperty:
+    """
+    Like @property but applies at the class level.
+
+
+    >>> class X(metaclass=classproperty.Meta):
+    ...   val = None
+    ...   @classproperty
+    ...   def foo(cls):
+    ...     return cls.val
+    ...   @foo.setter
+    ...   def foo(cls, val):
+    ...     cls.val = val
+    >>> X.foo
+    >>> X.foo = 3
+    >>> X.foo
+    3
+    >>> x = X()
+    >>> x.foo
+    3
+    >>> X.foo = 4
+    >>> x.foo
+    4
+
+    Setting the property on an instance affects the class.
+
+    >>> x.foo = 5
+    >>> x.foo
+    5
+    >>> X.foo
+    5
+    >>> vars(x)
+    {}
+    >>> X().foo
+    5
+
+    Attempting to set an attribute where no setter was defined
+    results in an AttributeError:
+
+    >>> class GetOnly(metaclass=classproperty.Meta):
+    ...   @classproperty
+    ...   def foo(cls):
+    ...     return 'bar'
+    >>> GetOnly.foo = 3
+    Traceback (most recent call last):
+    ...
+    AttributeError: can't set attribute
+
+    It is also possible to wrap a classmethod or staticmethod in
+    a classproperty.
+
+    >>> class Static(metaclass=classproperty.Meta):
+    ...   @classproperty
+    ...   @classmethod
+    ...   def foo(cls):
+    ...     return 'foo'
+    ...   @classproperty
+    ...   @staticmethod
+    ...   def bar():
+    ...     return 'bar'
+    >>> Static.foo
+    'foo'
+    >>> Static.bar
+    'bar'
+
+    *Legacy*
+
+    For compatibility, if the metaclass isn't specified, the
+    legacy behavior will be invoked.
+
+    >>> class X:
+    ...   val = None
+    ...   @classproperty
+    ...   def foo(cls):
+    ...     return cls.val
+    ...   @foo.setter
+    ...   def foo(cls, val):
+    ...     cls.val = val
+    >>> X.foo
+    >>> X.foo = 3
+    >>> X.foo
+    3
+    >>> x = X()
+    >>> x.foo
+    3
+    >>> X.foo = 4
+    >>> x.foo
+    4
+
+    Note, because the metaclass was not specified, setting
+    a value on an instance does not have the intended effect.
+
+    >>> x.foo = 5
+    >>> x.foo
+    5
+    >>> X.foo  # should be 5
+    4
+    >>> vars(x)  # should be empty
+    {'foo': 5}
+    >>> X().foo  # should be 5
+    4
+    """
+
+    class Meta(type):
+        def __setattr__(self, key, value):
+            obj = self.__dict__.get(key, None)
+            if type(obj) is classproperty:
+                return obj.__set__(self, value)
+            return super().__setattr__(key, value)
+
+    def __init__(self, fget, fset=None):
+        self.fget = self._ensure_method(fget)
+        self.fset = fset
+        fset and self.setter(fset)
+
+    def __get__(self, instance, owner=None):
+        return self.fget.__get__(None, owner)()
+
+    def __set__(self, owner, value):
+        if not self.fset:
+            raise AttributeError("can't set attribute")
+        if type(owner) is not classproperty.Meta:
+            owner = type(owner)
+        return self.fset.__get__(None, owner)(value)
+
+    def setter(self, fset):
+        self.fset = self._ensure_method(fset)
+        return self
+
+    @classmethod
+    def _ensure_method(cls, fn):
+        """
+        Ensure fn is a classmethod or staticmethod.
+        """
+        needs_method = not isinstance(fn, (classmethod, staticmethod))
+        return classmethod(fn) if needs_method else fn

venv/Lib/site-packages/keyring/compat/py312.py

@@ -0,0 +1,9 @@
+import sys
+
+__all__ = ['metadata']
+
+
+if sys.version_info >= (3, 12):
+    import importlib.metadata as metadata
+else:
+    import importlib_metadata as metadata

venv/Lib/site-packages/keyring/compat/py38.py

@@ -0,0 +1,9 @@
+import sys
+
+__all__ = ['files']
+
+
+if sys.version_info < (3, 9):
+    from importlib_resources import files
+else:
+    from importlib.resources import files

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

@@ -0,0 +1,56 @@
+import argparse
+import sys
+
+try:
+    import shtab
+except ImportError:
+    pass
+
+from .compat.py38 import files
+
+
+class _MissingCompletionAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string):
+        print("Install keyring[completion] for completion support.", file=sys.stderr)
+        parser.exit(1)
+
+
+def add_completion_notice(parser):
+    """Add completion argument to parser."""
+    parser.add_argument(
+        "--print-completion",
+        choices=["bash", "zsh", "tcsh"],
+        action=_MissingCompletionAction,
+        help="print shell completion script",
+    )
+    return parser
+
+
+def get_action(parser, option):
+    (match,) = (action for action in parser._actions if option in action.option_strings)
+    return match
+
+
+def install_completion(parser):
+    preamble = dict(
+        bash=files(__package__)
+        .joinpath('backend_complete.bash')
+        .read_text(encoding='utf-8'),
+        zsh=files(__package__)
+        .joinpath('backend_complete.zsh')
+        .read_text(encoding='utf-8'),
+    )
+    shtab.add_argument_to(parser, preamble=preamble)
+    get_action(parser, '--keyring-path').complete = shtab.DIR
+    get_action(parser, '--keyring-backend').complete = dict(
+        bash='_keyring_backends',
+        zsh='backend_complete',
+    )
+    return parser
+
+
+def install(parser):
+    try:
+        install_completion(parser)
+    except NameError:
+        add_completion_notice(parser)

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

@@ -0,0 +1,200 @@
+"""
+Core API functions and initialization routines.
+"""
+
+import configparser
+import logging
+import os
+import sys
+import typing
+
+from . import backend, credentials
+from .backends import fail
+from .util import platform_ as platform
+
+LimitCallable = typing.Callable[[backend.KeyringBackend], bool]
+
+log = logging.getLogger(__name__)
+
+_keyring_backend = None
+
+
+def set_keyring(keyring: backend.KeyringBackend) -> None:
+    """Set current keyring backend."""
+    global _keyring_backend
+    if not isinstance(keyring, backend.KeyringBackend):
+        raise TypeError("The keyring must be an instance of KeyringBackend")
+    _keyring_backend = keyring
+
+
+def get_keyring() -> backend.KeyringBackend:
+    """Get current keyring backend."""
+    if _keyring_backend is None:
+        init_backend()
+    return typing.cast(backend.KeyringBackend, _keyring_backend)
+
+
+def disable() -> None:
+    """
+    Configure the null keyring as the default.
+
+    >>> fs = getfixture('fs')
+    >>> disable()
+    >>> disable()
+    Traceback (most recent call last):
+    ...
+    RuntimeError: Refusing to overwrite...
+    """
+    root = platform.config_root()
+    try:
+        os.makedirs(root)
+    except OSError:
+        pass
+    filename = os.path.join(root, 'keyringrc.cfg')
+    if os.path.exists(filename):
+        msg = f"Refusing to overwrite {filename}"
+        raise RuntimeError(msg)
+    with open(filename, 'w', encoding='utf-8') as file:
+        file.write('[backend]\ndefault-keyring=keyring.backends.null.Keyring')
+
+
+def get_password(service_name: str, username: str) -> typing.Optional[str]:
+    """Get password from the specified service."""
+    return get_keyring().get_password(service_name, username)
+
+
+def set_password(service_name: str, username: str, password: str) -> None:
+    """Set password for the user in the specified service."""
+    get_keyring().set_password(service_name, username, password)
+
+
+def delete_password(service_name: str, username: str) -> None:
+    """Delete the password for the user in the specified service."""
+    get_keyring().delete_password(service_name, username)
+
+
+def get_credential(
+    service_name: str, username: typing.Optional[str]
+) -> typing.Optional[credentials.Credential]:
+    """Get a Credential for the specified service."""
+    return get_keyring().get_credential(service_name, username)
+
+
+def recommended(backend) -> bool:
+    return backend.priority >= 1
+
+
+def init_backend(limit: typing.Optional[LimitCallable] = None):
+    """
+    Load a detected backend.
+    """
+    set_keyring(_detect_backend(limit))
+
+
+def _detect_backend(limit: typing.Optional[LimitCallable] = None):
+    """
+    Return a keyring specified in the config file or infer the best available.
+
+    Limit, if supplied, should be a callable taking a backend and returning
+    True if that backend should be included for consideration.
+    """
+
+    # save the limit for the chainer to honor
+    backend._limit = limit
+    return (
+        load_env()
+        or load_config()
+        or max(
+            # all keyrings passing the limit filter
+            filter(limit, backend.get_all_keyring()),  # type: ignore[arg-type] #659
+            default=fail.Keyring(),
+            key=backend.by_priority,
+        )
+    )
+
+
+def _load_keyring_class(keyring_name: str) -> typing.Type[backend.KeyringBackend]:
+    """
+    Load the keyring class indicated by name.
+
+    These popular names are tested to ensure their presence.
+
+    >>> popular_names = [
+    ...      'keyring.backends.Windows.WinVaultKeyring',
+    ...      'keyring.backends.macOS.Keyring',
+    ...      'keyring.backends.kwallet.DBusKeyring',
+    ...      'keyring.backends.SecretService.Keyring',
+    ...  ]
+    >>> list(map(_load_keyring_class, popular_names))
+    [...]
+    """
+    module_name, sep, class_name = keyring_name.rpartition('.')
+    __import__(module_name)
+    module = sys.modules[module_name]
+    return getattr(module, class_name)
+
+
+def load_keyring(keyring_name: str) -> backend.KeyringBackend:
+    """
+    Load the specified keyring by name (a fully-qualified name to the
+    keyring, such as 'keyring.backends.file.PlaintextKeyring')
+    """
+    class_ = _load_keyring_class(keyring_name)
+    # invoke the priority to ensure it is viable, or raise a RuntimeError
+    class_.priority  # noqa: B018
+    return class_()
+
+
+def load_env() -> typing.Optional[backend.KeyringBackend]:
+    """Load a keyring configured in the environment variable."""
+    try:
+        return load_keyring(os.environ['PYTHON_KEYRING_BACKEND'])
+    except KeyError:
+        return None
+
+
+def _config_path():
+    return platform.config_root() / 'keyringrc.cfg'
+
+
+def _ensure_path(path):
+    if not path.exists():
+        raise FileNotFoundError(path)
+    return path
+
+
+def load_config() -> typing.Optional[backend.KeyringBackend]:
+    """Load a keyring using the config file in the config root."""
+
+    config = configparser.RawConfigParser()
+    try:
+        config.read(_ensure_path(_config_path()), encoding='utf-8')
+    except FileNotFoundError:
+        return None
+    _load_keyring_path(config)
+
+    # load the keyring class name, and then load this keyring
+    try:
+        if config.has_section("backend"):
+            keyring_name = config.get("backend", "default-keyring").strip()
+        else:
+            return None
+
+    except (configparser.NoOptionError, ImportError):
+        logger = logging.getLogger('keyring')
+        logger.warning(
+            "Keyring config file contains incorrect values.\n"
+            + f"Config file: {_config_path()}"
+        )
+        return None
+
+    return load_keyring(keyring_name)
+
+
+def _load_keyring_path(config: configparser.RawConfigParser) -> None:
+    "load the keyring-path option (if present)"
+    try:
+        path = config.get("backend", "keyring-path").strip()
+        sys.path.insert(0, os.path.expanduser(path))
+    except (configparser.NoOptionError, configparser.NoSectionError):
+        pass