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

venv/Lib/site-packages/twine/utils.py

@@ -0,0 +1,387 @@
+# Copyright 2013 Donald Stufft
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import argparse
+import collections
+import configparser
+import functools
+import logging
+import os
+import os.path
+import unicodedata
+from typing import Any, Callable, DefaultDict, Dict, Optional, Sequence, Union, cast
+from urllib.parse import urlparse
+from urllib.parse import urlunparse
+
+import requests
+import rfc3986
+import urllib3
+from requests.adapters import HTTPAdapter
+from requests_toolbelt.utils import user_agent
+
+import twine
+from twine import exceptions
+
+# Shim for input to allow testing.
+input_func = input
+
+DEFAULT_REPOSITORY = "https://upload.pypi.org/legacy/"
+TEST_REPOSITORY = "https://test.pypi.org/legacy/"
+
+DEFAULT_CONFIG_FILE = "~/.pypirc"
+
+# TODO: In general, it seems to be assumed that the values retrieved from
+# instances of this type aren't None, except for username and password.
+# Type annotations would be cleaner if this were Dict[str, str], but that
+# requires reworking the username/password handling, probably starting with
+# get_userpass_value.
+RepositoryConfig = Dict[str, Optional[str]]
+
+logger = logging.getLogger(__name__)
+
+
+def get_config(path: str) -> Dict[str, RepositoryConfig]:
+    """Read repository configuration from a file (i.e. ~/.pypirc).
+
+    Format: https://packaging.python.org/specifications/pypirc/
+
+    If the default config file doesn't exist, return a default configuration for
+    pypyi and testpypi.
+    """
+    realpath = os.path.realpath(os.path.expanduser(path))
+    parser = configparser.RawConfigParser()
+
+    try:
+        with open(realpath) as f:
+            parser.read_file(f)
+            logger.info(f"Using configuration from {realpath}")
+    except FileNotFoundError:
+        # User probably set --config-file, but the file can't be read
+        if path != DEFAULT_CONFIG_FILE:
+            raise
+
+    # server-login is obsolete, but retained for backwards compatibility
+    defaults: RepositoryConfig = {
+        "username": parser.get("server-login", "username", fallback=None),
+        "password": parser.get("server-login", "password", fallback=None),
+    }
+
+    config: DefaultDict[str, RepositoryConfig]
+    config = collections.defaultdict(lambda: defaults.copy())
+
+    index_servers = parser.get(
+        "distutils", "index-servers", fallback="pypi testpypi"
+    ).split()
+
+    # Don't require users to manually configure URLs for these repositories
+    config["pypi"]["repository"] = DEFAULT_REPOSITORY
+    if "testpypi" in index_servers:
+        config["testpypi"]["repository"] = TEST_REPOSITORY
+
+    # Optional configuration values for individual repositories
+    for repository in index_servers:
+        for key in [
+            "username",
+            "repository",
+            "password",
+            "ca_cert",
+            "client_cert",
+        ]:
+            if parser.has_option(repository, key):
+                config[repository][key] = parser.get(repository, key)
+
+    # Convert the defaultdict to a regular dict to prevent surprising behavior later on
+    return dict(config)
+
+
+def sanitize_url(url: str) -> str:
+    """Sanitize a URL.
+
+    Sanitize URLs, removing any user:password combinations and replacing them with
+    asterisks.  Returns the original URL if the string is a non-matching pattern.
+
+    :param url:
+        str containing a URL to sanitize.
+
+    return:
+        str either sanitized or as entered depending on pattern match.
+    """
+    uri = rfc3986.urlparse(url)
+    if uri.userinfo:
+        return cast(str, uri.copy_with(userinfo="*" * 8).unsplit())
+    return url
+
+
+def _validate_repository_url(repository_url: str) -> None:
+    """Validate the given url for allowed schemes and components."""
+    # Allowed schemes are http and https, based on whether the repository
+    # supports TLS or not, and scheme and host must be present in the URL
+    validator = (
+        rfc3986.validators.Validator()
+        .allow_schemes("http", "https")
+        .require_presence_of("scheme", "host")
+    )
+    try:
+        validator.validate(rfc3986.uri_reference(repository_url))
+    except rfc3986.exceptions.RFC3986Exception as exc:
+        raise exceptions.UnreachableRepositoryURLDetected(
+            f"Invalid repository URL: {exc.args[0]}."
+        )
+
+
+def get_repository_from_config(
+    config_file: str,
+    repository: str,
+    repository_url: Optional[str] = None,
+) -> RepositoryConfig:
+    """Get repository config command-line values or the .pypirc file."""
+    # Prefer CLI `repository_url` over `repository` or .pypirc
+    if repository_url:
+        _validate_repository_url(repository_url)
+        return _config_from_repository_url(repository_url)
+
+    try:
+        config = get_config(config_file)[repository]
+    except OSError as exc:
+        raise exceptions.InvalidConfiguration(str(exc))
+    except KeyError:
+        raise exceptions.InvalidConfiguration(
+            f"Missing '{repository}' section from {config_file}.\n"
+            f"More info: https://packaging.python.org/specifications/pypirc/ "
+        )
+    except configparser.Error:
+        # NOTE: We intentionally fully mask the configparser exception here,
+        # since it could leak tokens and other sensitive values.
+        raise exceptions.InvalidConfiguration(
+            f"Malformed configuration in {config_file}.\n"
+            f"More info: https://packaging.python.org/specifications/pypirc/ "
+        )
+
+    config["repository"] = normalize_repository_url(cast(str, config["repository"]))
+    return config
+
+
+_HOSTNAMES = {
+    "pypi.python.org",
+    "testpypi.python.org",
+    "upload.pypi.org",
+    "test.pypi.org",
+}
+
+
+def _config_from_repository_url(url: str) -> RepositoryConfig:
+    parsed = urlparse(url)
+    config = {"repository": url, "username": None, "password": None}
+    if parsed.username:
+        config["username"] = parsed.username
+        config["password"] = parsed.password
+        config["repository"] = cast(
+            str, rfc3986.urlparse(url).copy_with(userinfo=None).unsplit()
+        )
+    config["repository"] = normalize_repository_url(cast(str, config["repository"]))
+    return config
+
+
+def normalize_repository_url(url: str) -> str:
+    parsed = urlparse(url)
+    if parsed.netloc in _HOSTNAMES:
+        return urlunparse(("https",) + parsed[1:])
+    return urlunparse(parsed)
+
+
+def get_file_size(filename: str) -> str:
+    """Return the size of a file in KB, or MB if >= 1024 KB."""
+    file_size = os.path.getsize(filename) / 1024
+    size_unit = "KB"
+
+    if file_size > 1024:
+        file_size = file_size / 1024
+        size_unit = "MB"
+
+    return f"{file_size:.1f} {size_unit}"
+
+
+def check_status_code(response: requests.Response, verbose: bool) -> None:
+    """Generate a helpful message based on the response from the repository.
+
+    Raise a custom exception for recognized errors. Otherwise, print the
+    response content (based on the verbose option) before re-raising the
+    HTTPError.
+    """
+    if response.status_code == 410 and "pypi.python.org" in response.url:
+        raise exceptions.UploadToDeprecatedPyPIDetected(
+            f"It appears you're uploading to pypi.python.org (or "
+            f"testpypi.python.org). You've received a 410 error response. "
+            f"Uploading to those sites is deprecated. The new sites are "
+            f"pypi.org and test.pypi.org. Try using {DEFAULT_REPOSITORY} (or "
+            f"{TEST_REPOSITORY}) to upload your packages instead. These are "
+            f"the default URLs for Twine now. More at "
+            f"https://packaging.python.org/guides/migrating-to-pypi-org/."
+        )
+    elif response.status_code == 405 and "pypi.org" in response.url:
+        raise exceptions.InvalidPyPIUploadURL(
+            f"It appears you're trying to upload to pypi.org but have an "
+            f"invalid URL. You probably want one of these two URLs: "
+            f"{DEFAULT_REPOSITORY} or {TEST_REPOSITORY}. Check your "
+            f"--repository-url value."
+        )
+
+    try:
+        response.raise_for_status()
+    except requests.HTTPError as err:
+        if not verbose:
+            logger.warning(
+                "Error during upload. "
+                "Retry with the --verbose option for more details."
+            )
+
+        raise err
+
+
+def get_userpass_value(
+    cli_value: Optional[str],
+    config: RepositoryConfig,
+    key: str,
+    prompt_strategy: Optional[Callable[[], str]] = None,
+) -> Optional[str]:
+    """Get a credential (e.g. a username or password) from the configuration.
+
+    Uses the following rules:
+
+    1. If ``cli_value`` is specified, use that.
+    2. If ``config[key]`` is specified, use that.
+    3. If ``prompt_strategy`` is specified, use its return value.
+    4. Otherwise return ``None``
+
+    :param cli_value:
+        The value supplied from the command line.
+    :param config:
+        A dictionary of repository configuration values.
+    :param key:
+        The credential to look up in ``config``, e.g. ``"username"`` or ``"password"``.
+    :param prompt_strategy:
+        An argumentless function to get the value, e.g. from keyring or by prompting
+        the user.
+
+    :return:
+        The credential value, i.e. the username or password.
+    """
+    if cli_value is not None:
+        logger.info(f"{key} set by command options")
+        return cli_value
+
+    elif config.get(key) is not None:
+        logger.info(f"{key} set from config file")
+        return config[key]
+
+    elif prompt_strategy:
+        warning = ""
+        value = prompt_strategy()
+
+        if not value:
+            warning = f"Your {key} is empty"
+        elif any(unicodedata.category(c).startswith("C") for c in value):
+            # See https://www.unicode.org/reports/tr44/#General_Category_Values
+            # Most common case is "\x16" when pasting in Windows Command Prompt
+            warning = f"Your {key} contains control characters"
+
+        if warning:
+            logger.warning(f"{warning}. Did you enter it correctly?")
+            logger.warning(
+                "See https://twine.readthedocs.io/#entering-credentials "
+                "for more information."
+            )
+
+        return value
+
+    else:
+        return None
+
+
+#: Get the CA bundle via :func:`get_userpass_value`.
+get_cacert = functools.partial(get_userpass_value, key="ca_cert")
+
+#: Get the client certificate via :func:`get_userpass_value`.
+get_clientcert = functools.partial(get_userpass_value, key="client_cert")
+
+
+def make_requests_session() -> requests.Session:
+    """Prepare a requests Session with retries & twine's user-agent string."""
+    s = requests.Session()
+
+    retry = urllib3.Retry(
+        allowed_methods=["GET"],
+        connect=5,
+        total=10,
+        status_forcelist=[500, 501, 502, 503],
+    )
+
+    for scheme in ("http://", "https://"):
+        s.mount(scheme, HTTPAdapter(max_retries=retry))
+
+    s.headers["User-Agent"] = (
+        user_agent.UserAgentBuilder("twine", twine.__version__)
+        .include_implementation()
+        .build()
+    )
+    return s
+
+
+class EnvironmentDefault(argparse.Action):
+    """Get values from environment variable."""
+
+    def __init__(
+        self,
+        env: str,
+        required: bool = True,
+        default: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        default = os.environ.get(env, default)
+        self.env = env
+        if default:
+            required = False
+        super().__init__(default=default, required=required, **kwargs)
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: Union[str, Sequence[Any], None],
+        option_string: Optional[str] = None,
+    ) -> None:
+        setattr(namespace, self.dest, values)
+
+
+class EnvironmentFlag(argparse.Action):
+    """Set boolean flag from environment variable."""
+
+    def __init__(self, env: str, **kwargs: Any) -> None:
+        default = self.bool_from_env(os.environ.get(env))
+        self.env = env
+        super().__init__(default=default, nargs=0, **kwargs)
+
+    def __call__(
+        self,
+        parser: argparse.ArgumentParser,
+        namespace: argparse.Namespace,
+        values: Union[str, Sequence[Any], None],
+        option_string: Optional[str] = None,
+    ) -> None:
+        setattr(namespace, self.dest, True)
+
+    @staticmethod
+    def bool_from_env(val: Optional[str]) -> bool:
+        """Allow '0' and 'false' and 'no' to be False."""
+        falsey = {"0", "false", "no"}
+        return bool(val and val.lower() not in falsey)

venv/Lib/site-packages/twine/wheel.py

@@ -0,0 +1,81 @@
+# Copyright 2013 Donald Stufft
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import re
+import zipfile
+from typing import List
+
+from twine import distribution
+from twine import exceptions
+
+wheel_file_re = re.compile(
+    r"""^(?P<namever>(?P<name>.+?)(-(?P<ver>\d.+?))?)
+        ((-(?P<build>\d.*?))?-(?P<pyver>.+?)-(?P<abi>.+?)-(?P<plat>.+?)
+        \.whl|\.dist-info)$""",
+    re.VERBOSE,
+)
+
+
+class Wheel(distribution.Distribution):
+    def __init__(self, filename: str) -> None:
+        if not os.path.exists(filename):
+            raise exceptions.InvalidDistribution(f"No such file: {filename}")
+        self.filename = filename
+
+    @property
+    def py_version(self) -> str:
+        wheel_info = wheel_file_re.match(os.path.basename(self.filename))
+        if wheel_info is None:
+            return "any"
+        else:
+            return wheel_info.group("pyver")
+
+    @staticmethod
+    def find_candidate_metadata_files(names: List[str]) -> List[List[str]]:
+        """Filter files that may be METADATA files."""
+        tuples = [x.split("/") for x in names if "METADATA" in x]
+        return [x[1] for x in sorted((len(x), x) for x in tuples)]
+
+    def read(self) -> bytes:
+        fqn = os.path.abspath(os.path.normpath(self.filename))
+        if not os.path.exists(fqn):
+            raise exceptions.InvalidDistribution("No such file: %s" % fqn)
+
+        if fqn.endswith(".whl"):
+            archive = zipfile.ZipFile(fqn)
+            names = archive.namelist()
+
+            def read_file(name: str) -> bytes:
+                return archive.read(name)
+
+        else:
+            raise exceptions.InvalidDistribution(
+                "Not a known archive format for file: %s" % fqn
+            )
+
+        searched_files: List[str] = []
+        try:
+            for path in self.find_candidate_metadata_files(names):
+                candidate = "/".join(path)
+                data = read_file(candidate)
+                if b"Metadata-Version" in data:
+                    return data
+                searched_files.append(candidate)
+        finally:
+            archive.close()
+
+        raise exceptions.InvalidDistribution(
+            "No METADATA in archive or METADATA missing 'Metadata-Version': "
+            "%s (searched %s)" % (fqn, ",".join(searched_files))
+        )

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

@@ -0,0 +1,211 @@
+"""
+Python HTTP library with thread-safe connection pooling, file post support, user friendly, and more
+"""
+
+from __future__ import annotations
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+import sys
+import typing
+import warnings
+from logging import NullHandler
+
+from . import exceptions
+from ._base_connection import _TYPE_BODY
+from ._collections import HTTPHeaderDict
+from ._version import __version__
+from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url
+from .filepost import _TYPE_FIELDS, encode_multipart_formdata
+from .poolmanager import PoolManager, ProxyManager, proxy_from_url
+from .response import BaseHTTPResponse, HTTPResponse
+from .util.request import make_headers
+from .util.retry import Retry
+from .util.timeout import Timeout
+
+# Ensure that Python is compiled with OpenSSL 1.1.1+
+# If the 'ssl' module isn't available at all that's
+# fine, we only care if the module is available.
+try:
+    import ssl
+except ImportError:
+    pass
+else:
+    if not ssl.OPENSSL_VERSION.startswith("OpenSSL "):  # Defensive:
+        warnings.warn(
+            "urllib3 v2 only supports OpenSSL 1.1.1+, currently "
+            f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. "
+            "See: https://github.com/urllib3/urllib3/issues/3020",
+            exceptions.NotOpenSSLWarning,
+        )
+    elif ssl.OPENSSL_VERSION_INFO < (1, 1, 1):  # Defensive:
+        raise ImportError(
+            "urllib3 v2 only supports OpenSSL 1.1.1+, currently "
+            f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. "
+            "See: https://github.com/urllib3/urllib3/issues/2168"
+        )
+
+__author__ = "Andrey Petrov (andrey.petrov@shazow.net)"
+__license__ = "MIT"
+__version__ = __version__
+
+__all__ = (
+    "HTTPConnectionPool",
+    "HTTPHeaderDict",
+    "HTTPSConnectionPool",
+    "PoolManager",
+    "ProxyManager",
+    "HTTPResponse",
+    "Retry",
+    "Timeout",
+    "add_stderr_logger",
+    "connection_from_url",
+    "disable_warnings",
+    "encode_multipart_formdata",
+    "make_headers",
+    "proxy_from_url",
+    "request",
+    "BaseHTTPResponse",
+)
+
+logging.getLogger(__name__).addHandler(NullHandler())
+
+
+def add_stderr_logger(
+    level: int = logging.DEBUG,
+) -> logging.StreamHandler[typing.TextIO]:
+    """
+    Helper for quickly adding a StreamHandler to the logger. Useful for
+    debugging.
+
+    Returns the handler after adding it.
+    """
+    # This method needs to be in this __init__.py to get the __name__ correct
+    # even if urllib3 is vendored within another package.
+    logger = logging.getLogger(__name__)
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
+    logger.addHandler(handler)
+    logger.setLevel(level)
+    logger.debug("Added a stderr logging handler to logger: %s", __name__)
+    return handler
+
+
+# ... Clean up.
+del NullHandler
+
+
+# All warning filters *must* be appended unless you're really certain that they
+# shouldn't be: otherwise, it's very hard for users to use most Python
+# mechanisms to silence them.
+# SecurityWarning's always go off by default.
+warnings.simplefilter("always", exceptions.SecurityWarning, append=True)
+# InsecurePlatformWarning's don't vary between requests, so we keep it default.
+warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True)
+
+
+def disable_warnings(category: type[Warning] = exceptions.HTTPWarning) -> None:
+    """
+    Helper for quickly disabling all urllib3 warnings.
+    """
+    warnings.simplefilter("ignore", category)
+
+
+_DEFAULT_POOL = PoolManager()
+
+
+def request(
+    method: str,
+    url: str,
+    *,
+    body: _TYPE_BODY | None = None,
+    fields: _TYPE_FIELDS | None = None,
+    headers: typing.Mapping[str, str] | None = None,
+    preload_content: bool | None = True,
+    decode_content: bool | None = True,
+    redirect: bool | None = True,
+    retries: Retry | bool | int | None = None,
+    timeout: Timeout | float | int | None = 3,
+    json: typing.Any | None = None,
+) -> BaseHTTPResponse:
+    """
+    A convenience, top-level request method. It uses a module-global ``PoolManager`` instance.
+    Therefore, its side effects could be shared across dependencies relying on it.
+    To avoid side effects create a new ``PoolManager`` instance and use it instead.
+    The method does not accept low-level ``**urlopen_kw`` keyword arguments.
+
+    :param method:
+        HTTP request method (such as GET, POST, PUT, etc.)
+
+    :param url:
+        The URL to perform the request on.
+
+    :param body:
+        Data to send in the request body, either :class:`str`, :class:`bytes`,
+        an iterable of :class:`str`/:class:`bytes`, or a file-like object.
+
+    :param fields:
+        Data to encode and send in the request body.
+
+    :param headers:
+        Dictionary of custom headers to send, such as User-Agent,
+        If-None-Match, etc.
+
+    :param bool preload_content:
+        If True, the response's body will be preloaded into memory.
+
+    :param bool decode_content:
+        If True, will attempt to decode the body based on the
+        'content-encoding' header.
+
+    :param redirect:
+        If True, automatically handle redirects (status codes 301, 302,
+        303, 307, 308). Each redirect counts as a retry. Disabling retries
+        will disable redirect, too.
+
+    :param retries:
+        Configure the number of retries to allow before raising a
+        :class:`~urllib3.exceptions.MaxRetryError` exception.
+
+        If ``None`` (default) will retry 3 times, see ``Retry.DEFAULT``. Pass a
+        :class:`~urllib3.util.retry.Retry` object for fine-grained control
+        over different types of retries.
+        Pass an integer number to retry connection errors that many times,
+        but no other types of errors. Pass zero to never retry.
+
+        If ``False``, then retries are disabled and any exception is raised
+        immediately. Also, instead of raising a MaxRetryError on redirects,
+        the redirect response will be returned.
+
+    :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int.
+
+    :param timeout:
+        If specified, overrides the default timeout for this one
+        request. It may be a float (in seconds) or an instance of
+        :class:`urllib3.util.Timeout`.
+
+    :param json:
+        Data to encode and send as JSON with UTF-encoded in the request body.
+        The ``"Content-Type"`` header will be set to ``"application/json"``
+        unless specified otherwise.
+    """
+
+    return _DEFAULT_POOL.request(
+        method,
+        url,
+        body=body,
+        fields=fields,
+        headers=headers,
+        preload_content=preload_content,
+        decode_content=decode_content,
+        redirect=redirect,
+        retries=retries,
+        timeout=timeout,
+        json=json,
+    )
+
+
+if sys.platform == "emscripten":
+    from .contrib.emscripten import inject_into_urllib3  # noqa: 401
+
+    inject_into_urllib3()