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

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

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-import abc
-import os
-
-
-class Credential(metaclass=abc.ABCMeta):
-    """Abstract class to manage credentials"""
-
-    @abc.abstractproperty
-    def username(self) -> str: ...
-
-    @abc.abstractproperty
-    def password(self) -> str: ...
-
-    def _vars(self) -> dict[str, str]:
-        return dict(username=self.username, password=self.password)
-
-
-class SimpleCredential(Credential):
-    """Simple credentials implementation"""
-
-    def __init__(self, username: str, password: str):
-        self._username = username
-        self._password = password
-
-    @property
-    def username(self) -> str:
-        return self._username
-
-    @property
-    def password(self) -> str:
-        return self._password
-
-
-class AnonymousCredential(SimpleCredential):
-    def __init__(self, password: str):
-        self._password = password
-
-    @property
-    def username(self) -> str:
-        raise ValueError("Anonymous credential has no username")
-
-    def _vars(self) -> dict[str, str]:
-        return dict(password=self.password)
-
-
-class EnvironCredential(Credential):
-    """
-    Source credentials from environment variables.
-
-    Actual sourcing is deferred until requested.
-
-    Supports comparison by equality.
-
-    >>> e1 = EnvironCredential('a', 'b')
-    >>> e2 = EnvironCredential('a', 'b')
-    >>> e3 = EnvironCredential('a', 'c')
-    >>> e1 == e2
-    True
-    >>> e2 == e3
-    False
-    """
-
-    def __init__(self, user_env_var: str, pwd_env_var: str):
-        self.user_env_var = user_env_var
-        self.pwd_env_var = pwd_env_var
-
-    def __eq__(self, other: object) -> bool:
-        return vars(self) == vars(other)
-
-    def _get_env(self, env_var: str) -> str:
-        """Helper to read an environment variable"""
-        value = os.environ.get(env_var)
-        if not value:
-            raise ValueError(f'Missing environment variable:{env_var}')
-        return value
-
-    @property
-    def username(self) -> str:
-        return self._get_env(self.user_env_var)
-
-    @property
-    def password(self) -> str:
-        return self._get_env(self.pwd_env_var)

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

@@ -1,29 +0,0 @@
-import functools
-
-import pluggy
-from jaraco.context import suppress
-
-import keyring.errors
-
-hookimpl = pluggy.HookimplMarker("devpiclient")
-
-
-def restore_signature(func):
-    # workaround for pytest-dev/pluggy#358
-    @functools.wraps(func)
-    def wrapper(url, username):
-        return func(url, username)
-
-    return wrapper
-
-
-@hookimpl()
-@restore_signature
-@suppress(keyring.errors.KeyringError)
-def devpiclient_get_password(url, username):
-    """
-    >>> pluggy._hooks.varnames(devpiclient_get_password)
-    (('url', 'username'), ())
-    >>>
-    """
-    return keyring.get_password(url, username)

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

@@ -1,67 +0,0 @@
-import sys
-import warnings
-
-
-class KeyringError(Exception):
-    """Base class for exceptions in keyring"""
-
-
-class PasswordSetError(KeyringError):
-    """Raised when the password can't be set."""
-
-
-class PasswordDeleteError(KeyringError):
-    """Raised when the password can't be deleted."""
-
-
-class InitError(KeyringError):
-    """Raised when the keyring could not be initialised"""
-
-
-class KeyringLocked(KeyringError):
-    """Raised when the keyring failed unlocking"""
-
-
-class NoKeyringError(KeyringError, RuntimeError):
-    """Raised when there is no keyring backend"""
-
-
-class ExceptionRaisedContext:
-    """
-    An exception-trapping context that indicates whether an exception was
-    raised.
-    """
-
-    def __init__(self, ExpectedException=Exception):
-        warnings.warn(
-            "ExceptionRaisedContext is deprecated; use `jaraco.context.ExceptionTrap`",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self.ExpectedException = ExpectedException
-        self.exc_info = None
-
-    def __enter__(self):
-        self.exc_info = object.__new__(ExceptionInfo)
-        return self.exc_info
-
-    def __exit__(self, *exc_info):
-        self.exc_info.__init__(*exc_info)
-        return self.exc_info.type and issubclass(
-            self.exc_info.type, self.ExpectedException
-        )
-
-
-class ExceptionInfo:
-    def __init__(self, *info):
-        if not info:
-            info = sys.exc_info()
-        self.type, self.value, _ = info
-
-    def __bool__(self):
-        """
-        Return True if an exception occurred
-        """
-        return bool(self.type)
-
-    __nonzero__ = __bool__

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

@@ -1,39 +0,0 @@
-"""
-urllib2.HTTPPasswordMgr object using the keyring, for use with the
-urllib2.HTTPBasicAuthHandler.
-
-usage:
-    import urllib2
-    handlers = [urllib2.HTTPBasicAuthHandler(PasswordMgr())]
-    urllib2.install_opener(handlers)
-    urllib2.urlopen(...)
-
-This will prompt for a password if one is required and isn't already
-in the keyring. Then, it adds it to the keyring for subsequent use.
-"""
-
-import getpass
-
-from . import delete_password, get_password, set_password
-
-
-class PasswordMgr:
-    def get_username(self, realm, authuri):
-        return getpass.getuser()
-
-    def add_password(self, realm, authuri, password):
-        user = self.get_username(realm, authuri)
-        set_password(realm, user, password)
-
-    def find_user_password(self, realm, authuri):
-        user = self.get_username(realm, authuri)
-        password = get_password(realm, user)
-        if password is None:
-            prompt = f'password for {user}@{realm} for {authuri}: '
-            password = getpass.getpass(prompt)
-            set_password(realm, user, password)
-        return user, password
-
-    def clear_password(self, realm, authuri):
-        user = self.get_username(realm, authuri)
-        delete_password(realm, user)

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

@@ -1,200 +0,0 @@
-"""
-Common test functionality for backends.
-"""
-
-import os
-import string
-
-import pytest
-
-from keyring import errors
-
-from .util import random_string
-
-# unicode only characters
-# Sourced from The Quick Brown Fox... Pangrams
-# http://www.columbia.edu/~fdc/utf8/
-UNICODE_CHARS = (
-    "זהכיףסתםלשמועאיךתנצחקרפדעץטובבגן"
-    "ξεσκεπάζωτηνψυχοφθόραβδελυγμία"
-    "Съешьжеещёэтихмягкихфранцузскихбулокдавыпейчаю"
-    "Жълтатадюлябешещастливачепухъткойтоцъфназамръзнакатогьон"
-)
-
-# ensure no-ascii chars slip by - watch your editor!
-assert min(ord(char) for char in UNICODE_CHARS) > 127
-
-
-def is_ascii_printable(s):
-    return all(32 <= ord(c) < 127 for c in s)
-
-
-class BackendBasicTests:
-    """Test for the keyring's basic functions. password_set and password_get"""
-
-    DIFFICULT_CHARS = string.whitespace + string.punctuation
-
-    @pytest.fixture(autouse=True)
-    def _init_properties(self, request):
-        self.keyring = self.init_keyring()
-        self.credentials_created = set()
-        request.addfinalizer(self.cleanup)
-
-    def cleanup(self):
-        for item in self.credentials_created:
-            self.keyring.delete_password(*item)
-
-    def set_password(self, service, username, password):
-        # set the password and save the result so the test runner can clean
-        #  up after if necessary.
-        self.keyring.set_password(service, username, password)
-        self.credentials_created.add((service, username))
-
-    def check_set_get(self, service, username, password):
-        keyring = self.keyring
-
-        # for the non-existent password
-        assert keyring.get_password(service, username) is None
-
-        # common usage
-        self.set_password(service, username, password)
-        assert keyring.get_password(service, username) == password
-
-        # for the empty password
-        self.set_password(service, username, "")
-        assert keyring.get_password(service, username) == ""
-
-    def test_password_set_get(self):
-        password = random_string(20)
-        username = random_string(20)
-        service = random_string(20)
-        self.check_set_get(service, username, password)
-
-    def test_set_after_set_blank(self):
-        service = random_string(20)
-        username = random_string(20)
-        self.keyring.set_password(service, username, "")
-        self.keyring.set_password(service, username, "non-blank")
-
-    def test_difficult_chars(self):
-        password = random_string(20, self.DIFFICULT_CHARS)
-        username = random_string(20, self.DIFFICULT_CHARS)
-        service = random_string(20, self.DIFFICULT_CHARS)
-        self.check_set_get(service, username, password)
-
-    def test_delete_present(self):
-        password = random_string(20, self.DIFFICULT_CHARS)
-        username = random_string(20, self.DIFFICULT_CHARS)
-        service = random_string(20, self.DIFFICULT_CHARS)
-        self.keyring.set_password(service, username, password)
-        self.keyring.delete_password(service, username)
-        assert self.keyring.get_password(service, username) is None
-
-    def test_delete_not_present(self):
-        username = random_string(20, self.DIFFICULT_CHARS)
-        service = random_string(20, self.DIFFICULT_CHARS)
-        with pytest.raises(errors.PasswordDeleteError):
-            self.keyring.delete_password(service, username)
-
-    def test_delete_one_in_group(self):
-        username1 = random_string(20, self.DIFFICULT_CHARS)
-        username2 = random_string(20, self.DIFFICULT_CHARS)
-        password = random_string(20, self.DIFFICULT_CHARS)
-        service = random_string(20, self.DIFFICULT_CHARS)
-        self.keyring.set_password(service, username1, password)
-        self.set_password(service, username2, password)
-        self.keyring.delete_password(service, username1)
-        assert self.keyring.get_password(service, username2) == password
-
-    def test_name_property(self):
-        assert is_ascii_printable(self.keyring.name)
-
-    def test_unicode_chars(self):
-        password = random_string(20, UNICODE_CHARS)
-        username = random_string(20, UNICODE_CHARS)
-        service = random_string(20, UNICODE_CHARS)
-        self.check_set_get(service, username, password)
-
-    def test_unicode_and_ascii_chars(self):
-        source = (
-            random_string(10, UNICODE_CHARS)
-            + random_string(10)
-            + random_string(10, self.DIFFICULT_CHARS)
-        )
-        password = random_string(20, source)
-        username = random_string(20, source)
-        service = random_string(20, source)
-        self.check_set_get(service, username, password)
-
-    def test_different_user(self):
-        """
-        Issue #47 reports that WinVault isn't storing passwords for
-        multiple users. This test exercises that test for each of the
-        backends.
-        """
-
-        keyring = self.keyring
-        self.set_password('service1', 'user1', 'password1')
-        self.set_password('service1', 'user2', 'password2')
-        assert keyring.get_password('service1', 'user1') == 'password1'
-        assert keyring.get_password('service1', 'user2') == 'password2'
-        self.set_password('service2', 'user3', 'password3')
-        assert keyring.get_password('service1', 'user1') == 'password1'
-
-    def test_credential(self):
-        keyring = self.keyring
-
-        cred = keyring.get_credential('service', None)
-        assert cred is None
-
-        self.set_password('service1', 'user1', 'password1')
-        self.set_password('service1', 'user2', 'password2')
-
-        cred = keyring.get_credential('service1', None)
-        assert cred is None or (cred.username, cred.password) in (
-            ('user1', 'password1'),
-            ('user2', 'password2'),
-        )
-
-        cred = keyring.get_credential('service1', 'user2')
-        assert cred is not None
-        assert (cred.username, cred.password) in (
-            ('user1', 'password1'),
-            ('user2', 'password2'),
-        )
-
-    @pytest.mark.xfail("platform.system() == 'Windows'", reason="#668")
-    def test_empty_username(self):
-        with pytest.deprecated_call():
-            self.set_password('service1', '', 'password1')
-        assert self.keyring.get_password('service1', '') == 'password1'
-
-    def test_set_properties(self, monkeypatch):
-        env = dict(KEYRING_PROPERTY_FOO_BAR='fizz buzz', OTHER_SETTING='ignore me')
-        monkeypatch.setattr(os, 'environ', env)
-        self.keyring.set_properties_from_env()
-        assert self.keyring.foo_bar == 'fizz buzz'
-
-    def test_new_with_properties(self):
-        alt = self.keyring.with_properties(foo='bar')
-        assert alt is not self.keyring
-        assert alt.foo == 'bar'
-        with pytest.raises(AttributeError):
-            self.keyring.foo  # noqa: B018
-
-    def test_wrong_username_returns_none(self):
-        keyring = self.keyring
-        service = 'test_wrong_username_returns_none'
-        cred = keyring.get_credential(service, None)
-        assert cred is None
-
-        password_1 = 'password1'
-        password_2 = 'password2'
-        self.set_password(service, 'user1', password_1)
-        self.set_password(service, 'user2', password_2)
-
-        assert keyring.get_credential(service, "user1").password == password_1
-        assert keyring.get_credential(service, "user2").password == password_2
-
-        # Missing/wrong username should not return a cred
-        assert keyring.get_credential(service, "nobody!") is None

venv/Lib/site-packages/keyring/testing/util.py

@@ -1,68 +0,0 @@
-import contextlib
-import os
-import random
-import string
-import sys
-
-
-class ImportKiller:
-    "Context manager to make an import of a given name or names fail."
-
-    def __init__(self, *names):
-        self.names = names
-
-    def find_module(self, fullname, path=None):
-        if fullname in self.names:
-            return self
-
-    def load_module(self, fullname):
-        assert fullname in self.names
-        raise ImportError(fullname)
-
-    def __enter__(self):
-        self.original = {}
-        for name in self.names:
-            self.original[name] = sys.modules.pop(name, None)
-        sys.meta_path.insert(0, self)
-
-    def __exit__(self, *args):
-        sys.meta_path.remove(self)
-        for key, value in self.original.items():
-            if value is not None:
-                sys.modules[key] = value
-
-
-@contextlib.contextmanager
-def NoNoneDictMutator(destination, **changes):
-    """Helper context manager to make and unmake changes to a dict.
-
-    A None is not a valid value for the destination, and so means that the
-    associated name should be removed."""
-    original = {}
-    for key, value in changes.items():
-        original[key] = destination.get(key)
-        if value is None:
-            if key in destination:
-                del destination[key]
-        else:
-            destination[key] = value
-    yield
-    for key, value in original.items():
-        if value is None:
-            if key in destination:
-                del destination[key]
-        else:
-            destination[key] = value
-
-
-def Environ(**changes):
-    """A context manager to temporarily change the os.environ"""
-    return NoNoneDictMutator(os.environ, **changes)
-
-
-ALPHABET = string.ascii_letters + string.digits
-
-
-def random_string(k, source=ALPHABET):
-    """Generate a random string with length <i>k</i>"""
-    return ''.join(random.choice(source) for _unused in range(k))

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

@@ -1,11 +0,0 @@
-import contextlib
-
-
-def suppress_exceptions(callables, exceptions=Exception):
-    """
-    yield the results of calling each element of callables, suppressing
-    any indicated exceptions.
-    """
-    for callable in callables:
-        with contextlib.suppress(exceptions):
-            yield callable()

venv/Lib/site-packages/keyring/util/platform_.py

@@ -1,40 +0,0 @@
-import os
-import pathlib
-import platform
-
-
-def _data_root_Windows():
-    release, version, csd, ptype = platform.win32_ver()
-    root = pathlib.Path(
-        os.environ.get('LOCALAPPDATA', os.environ.get('ProgramData', '.'))
-    )
-    return root / 'Python Keyring'
-
-
-def _data_root_Linux():
-    """
-    Use freedesktop.org Base Dir Specification to determine storage
-    location.
-    """
-    fallback = pathlib.Path.home() / '.local/share'
-    root = os.environ.get('XDG_DATA_HOME', None) or fallback
-    return pathlib.Path(root, 'python_keyring')
-
-
-_config_root_Windows = _data_root_Windows
-
-
-def _config_root_Linux():
-    """
-    Use freedesktop.org Base Dir Specification to determine config
-    location.
-    """
-    fallback = pathlib.Path.home() / '.config'
-    key = 'XDG_CONFIG_HOME'
-    root = os.environ.get(key, None) or fallback
-    return pathlib.Path(root, 'python_keyring')
-
-
-# by default, use Unix convention
-data_root = globals().get('_data_root_' + platform.system(), _data_root_Linux)
-config_root = globals().get('_config_root_' + platform.system(), _config_root_Linux)

venv/Lib/site-packages/markdown_it/__init__.py

@@ -1,6 +0,0 @@
-"""A Python port of Markdown-It"""
-
-__all__ = ("MarkdownIt",)
-__version__ = "4.0.0"
-
-from .main import MarkdownIt

venv/Lib/site-packages/markdown_it/_compat.py

@@ -1 +0,0 @@
-from __future__ import annotations

venv/Lib/site-packages/markdown_it/_punycode.py

@@ -1,67 +0,0 @@
-# Copyright 2014 Mathias Bynens <https://mathiasbynens.be/>
-# Copyright 2021 Taneli Hukkinen
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-import codecs
-from collections.abc import Callable
-import re
-
-REGEX_SEPARATORS = re.compile(r"[\x2E\u3002\uFF0E\uFF61]")
-REGEX_NON_ASCII = re.compile(r"[^\0-\x7E]")
-
-
-def encode(uni: str) -> str:
-    return codecs.encode(uni, encoding="punycode").decode()
-
-
-def decode(ascii: str) -> str:
-    return codecs.decode(ascii, encoding="punycode")  # type: ignore
-
-
-def map_domain(string: str, fn: Callable[[str], str]) -> str:
-    parts = string.split("@")
-    result = ""
-    if len(parts) > 1:
-        # In email addresses, only the domain name should be punycoded. Leave
-        # the local part (i.e. everything up to `@`) intact.
-        result = parts[0] + "@"
-        string = parts[1]
-    labels = REGEX_SEPARATORS.split(string)
-    encoded = ".".join(fn(label) for label in labels)
-    return result + encoded
-
-
-def to_unicode(obj: str) -> str:
-    def mapping(obj: str) -> str:
-        if obj.startswith("xn--"):
-            return decode(obj[4:].lower())
-        return obj
-
-    return map_domain(obj, mapping)
-
-
-def to_ascii(obj: str) -> str:
-    def mapping(obj: str) -> str:
-        if REGEX_NON_ASCII.search(obj):
-            return "xn--" + encode(obj)
-        return obj
-
-    return map_domain(obj, mapping)