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

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

@@ -1,220 +0,0 @@
-"""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

@@ -1,7 +0,0 @@
-__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

@@ -1,169 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,200 +0,0 @@
-"""
-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