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

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

@@ -1,246 +0,0 @@
-# Copyright 2015 Ian Cordasco
-#
-# 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 logging
-from typing import Any, Dict, List, Optional, Set, Tuple
-
-import requests
-import requests_toolbelt
-import rich.progress
-from rich import print
-
-from twine import package as package_file
-from twine.utils import make_requests_session
-
-LEGACY_PYPI = "https://pypi.python.org/"
-LEGACY_TEST_PYPI = "https://testpypi.python.org/"
-WAREHOUSE = "https://upload.pypi.org/"
-OLD_WAREHOUSE = "https://upload.pypi.io/"
-TEST_WAREHOUSE = "https://test.pypi.org/"
-WAREHOUSE_WEB = "https://pypi.org/"
-
-logger = logging.getLogger(__name__)
-
-
-class Repository:
-    def __init__(
-        self,
-        repository_url: str,
-        username: Optional[str],
-        password: Optional[str],
-        disable_progress_bar: bool = False,
-    ) -> None:
-        self.url = repository_url
-
-        self.session = make_requests_session()
-        # requests.Session.auth should be Union[None, Tuple[str, str], ...]
-        # But username or password could be None
-        # See TODO for utils.RepositoryConfig
-        self.session.auth = (
-            (username or "", password or "") if username or password else None
-        )
-        logger.info(f"username: {username if username else '<empty>'}")
-        logger.info(f"password: <{'hidden' if password else 'empty'}>")
-
-        # Working around https://github.com/python/typing/issues/182
-        self._releases_json_data: Dict[str, Dict[str, Any]] = {}
-        self.disable_progress_bar = disable_progress_bar
-
-    def close(self) -> None:
-        self.session.close()
-
-    @staticmethod
-    def _convert_metadata_to_list_of_tuples(
-        data: package_file.PackageMetadata,
-    ) -> List[Tuple[str, Any]]:
-        # This does what ``warehouse.forklift.parse_form_metadata()`` does, in reverse.
-        data_to_send: List[Tuple[str, Any]] = []
-        for key, value in data.items():
-            if key == "gpg_signature":
-                assert isinstance(value, tuple)
-                data_to_send.append((key, value))
-            elif key == "project_urls":
-                assert isinstance(value, dict)
-                for name, url in value.items():
-                    data_to_send.append((key, f"{name}, {url}"))
-            elif key == "keywords":
-                assert isinstance(value, list)
-                data_to_send.append((key, ", ".join(value)))
-            elif isinstance(value, (list, tuple)):
-                data_to_send.extend((key, item) for item in value)
-            else:
-                assert isinstance(value, str)
-                data_to_send.append((key, value))
-        return data_to_send
-
-    def set_certificate_authority(self, cacert: Optional[str]) -> None:
-        if cacert:
-            self.session.verify = cacert
-
-    def set_client_certificate(self, clientcert: Optional[str]) -> None:
-        if clientcert:
-            self.session.cert = clientcert
-
-    def register(self, package: package_file.PackageFile) -> requests.Response:
-        print(f"Registering {package.basefilename}")
-
-        metadata = package.metadata_dictionary()
-        data_to_send = self._convert_metadata_to_list_of_tuples(metadata)
-        data_to_send.append((":action", "submit"))
-        data_to_send.append(("protocol_version", "1"))
-        encoder = requests_toolbelt.MultipartEncoder(data_to_send)
-        resp = self.session.post(
-            self.url,
-            data=encoder,
-            allow_redirects=False,
-            headers={"Content-Type": encoder.content_type},
-        )
-        # Bug 28. Try to silence a ResourceWarning by releasing the socket.
-        resp.close()
-        return resp
-
-    def _upload(self, package: package_file.PackageFile) -> requests.Response:
-        print(f"Uploading {package.basefilename}")
-
-        metadata = package.metadata_dictionary()
-        data_to_send = self._convert_metadata_to_list_of_tuples(metadata)
-        data_to_send.append((":action", "file_upload"))
-        data_to_send.append(("protocol_version", "1"))
-        with open(package.filename, "rb") as fp:
-            data_to_send.append(
-                (
-                    "content",
-                    (package.basefilename, fp, "application/octet-stream"),
-                )
-            )
-            encoder = requests_toolbelt.MultipartEncoder(data_to_send)
-
-            with rich.progress.Progress(
-                "[progress.percentage]{task.percentage:>3.0f}%",
-                rich.progress.BarColumn(),
-                rich.progress.DownloadColumn(),
-                "•",
-                rich.progress.TimeRemainingColumn(
-                    compact=True,
-                    elapsed_when_finished=True,
-                ),
-                "•",
-                rich.progress.TransferSpeedColumn(),
-                disable=self.disable_progress_bar,
-            ) as progress:
-                task_id = progress.add_task("", total=encoder.len)
-
-                monitor = requests_toolbelt.MultipartEncoderMonitor(
-                    encoder,
-                    lambda monitor: progress.update(
-                        task_id,
-                        completed=monitor.bytes_read,
-                    ),
-                )
-
-                resp = self.session.post(
-                    self.url,
-                    data=monitor,
-                    allow_redirects=False,
-                    headers={"Content-Type": monitor.content_type},
-                )
-
-        return resp
-
-    def upload(
-        self, package: package_file.PackageFile, max_redirects: int = 5
-    ) -> requests.Response:
-        number_of_redirects = 0
-        while number_of_redirects < max_redirects:
-            resp = self._upload(package)
-
-            if resp.status_code == requests.codes.OK:
-                return resp
-            if 500 <= resp.status_code < 600:
-                number_of_redirects += 1
-                logger.warning(
-                    f'Received "{resp.status_code}: {resp.reason}"'
-                    "\nPackage upload appears to have failed."
-                    f" Retry {number_of_redirects} of {max_redirects}."
-                )
-            else:
-                return resp
-
-        return resp
-
-    def package_is_uploaded(
-        self, package: package_file.PackageFile, bypass_cache: bool = False
-    ) -> bool:
-        """Determine if a package has been uploaded to PyPI already.
-
-        .. warning:: This does not support indexes other than PyPI or TestPyPI
-
-        :param package:
-            The package file that will otherwise be uploaded.
-        :type package:
-            :class:`~twine.package.PackageFile`
-        :param bypass_cache:
-            Force a request to PyPI.
-        :type bypass_cache:
-            bool
-        :returns:
-            True if package has already been uploaded, False otherwise
-        :rtype:
-            bool
-        """
-        # NOTE(sigmavirus24): Not all indices are PyPI and pypi.io doesn't
-        # have a similar interface for finding the package versions.
-        if not self.url.startswith((LEGACY_PYPI, WAREHOUSE, OLD_WAREHOUSE)):
-            return False
-
-        safe_name = package.safe_name
-        releases = None
-
-        if not bypass_cache:
-            releases = self._releases_json_data.get(safe_name)
-
-        if releases is None:
-            url = f"{LEGACY_PYPI}pypi/{safe_name}/json"
-            headers = {"Accept": "application/json"}
-            response = self.session.get(url, headers=headers)
-            if response.status_code == 200:
-                releases = response.json()["releases"]
-            else:
-                releases = {}
-            self._releases_json_data[safe_name] = releases
-
-        packages = releases.get(package.version, [])
-
-        for uploaded_package in packages:
-            if uploaded_package["filename"] == package.basefilename:
-                return True
-
-        return False
-
-    def release_urls(self, packages: List[package_file.PackageFile]) -> Set[str]:
-        if self.url.startswith(WAREHOUSE):
-            url = WAREHOUSE_WEB
-        elif self.url.startswith(TEST_WAREHOUSE):
-            url = TEST_WAREHOUSE
-        else:
-            return set()
-
-        return {
-            f"{url}project/{package.safe_name}/{package.version}/"
-            for package in packages
-        }
-
-    def verify_package_integrity(self, package: package_file.PackageFile) -> None:
-        # TODO(sigmavirus24): Add a way for users to download the package and
-        # check its hash against what it has locally.
-        pass

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

@@ -1,83 +0,0 @@
-import os
-import tarfile
-import zipfile
-from contextlib import suppress
-
-from twine import distribution
-from twine import exceptions
-
-
-class SDist(distribution.Distribution):
-    def __new__(cls, filename: str) -> "SDist":
-        if cls is not SDist:
-            return object.__new__(cls)
-
-        FORMATS = {
-            ".tar.gz": TarGzSDist,
-            ".zip": ZipSDist,
-        }
-
-        for extension, impl in FORMATS.items():
-            if filename.endswith(extension):
-                return impl(filename)
-        raise exceptions.InvalidDistribution(f"Unsupported sdist format: {filename}")
-
-    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:
-        return "source"
-
-
-class TarGzSDist(SDist):
-
-    def read(self) -> bytes:
-        with tarfile.open(self.filename, "r:gz") as sdist:
-            # The sdist must contain a single top-level direcotry...
-            root = os.path.commonpath(sdist.getnames())
-            if root in {".", "/", ""}:
-                raise exceptions.InvalidDistribution(
-                    f"Too many top-level members in sdist archive: {self.filename}"
-                )
-            # ...containing the package metadata in a ``PKG-INFO`` file.
-            with suppress(KeyError):
-                member = sdist.getmember(root.rstrip("/") + "/PKG-INFO")
-                if not member.isfile():
-                    raise exceptions.InvalidDistribution(
-                        f"PKG-INFO is not a regular file: {self.filename}"
-                    )
-                fd = sdist.extractfile(member)
-                assert fd is not None, "for mypy"
-                data = fd.read()
-                if b"Metadata-Version" in data:
-                    return data
-
-        raise exceptions.InvalidDistribution(
-            "No PKG-INFO in archive or "
-            f"PKG-INFO missing 'Metadata-Version': {self.filename}"
-        )
-
-
-class ZipSDist(SDist):
-
-    def read(self) -> bytes:
-        with zipfile.ZipFile(self.filename) as sdist:
-            # The sdist must contain a single top-level direcotry...
-            root = os.path.commonpath(sdist.namelist())
-            if root in {".", "/", ""}:
-                raise exceptions.InvalidDistribution(
-                    f"Too many top-level members in sdist archive: {self.filename}"
-                )
-            # ...containing the package metadata in a ``PKG-INFO`` file.
-            with suppress(KeyError):
-                data = sdist.read(root.rstrip("/") + "/PKG-INFO")
-                if b"Metadata-Version" in data:
-                    return data
-
-        raise exceptions.InvalidDistribution(
-            "No PKG-INFO in archive or "
-            f"PKG-INFO missing 'Metadata-Version': {self.filename}"
-        )

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

@@ -1,360 +0,0 @@
-"""Module containing logic for handling settings."""
-
-# Copyright 2018 Ian Stapleton Cordasco
-#
-# 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 contextlib
-import logging
-from typing import Any, Optional, cast
-
-from twine import auth
-from twine import exceptions
-from twine import repository
-from twine import utils
-
-
-class Settings:
-    """Object that manages the configuration for Twine.
-
-    This object can only be instantiated with keyword arguments.
-
-    For example,
-
-    .. code-block:: python
-
-        Settings(True, username='fakeusername')
-
-    Will raise a :class:`TypeError`. Instead, you would want
-
-    .. code-block:: python
-
-        Settings(sign=True, username='fakeusername')
-    """
-
-    def __init__(
-        self,
-        *,
-        attestations: bool = False,
-        sign: bool = False,
-        sign_with: str = "gpg",
-        identity: Optional[str] = None,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        non_interactive: bool = False,
-        comment: Optional[str] = None,
-        config_file: str = utils.DEFAULT_CONFIG_FILE,
-        skip_existing: bool = False,
-        cacert: Optional[str] = None,
-        client_cert: Optional[str] = None,
-        repository_name: str = "pypi",
-        repository_url: Optional[str] = None,
-        verbose: bool = False,
-        disable_progress_bar: bool = False,
-        **ignored_kwargs: Any,
-    ) -> None:
-        """Initialize our settings instance.
-
-        :param attestations:
-            Whether the package file should be uploaded with attestations.
-        :param sign:
-            Configure whether the package file should be signed.
-        :param sign_with:
-            The name of the executable used to sign the package with.
-        :param identity:
-            The GPG identity that should be used to sign the package file.
-        :param username:
-            The username used to authenticate to the repository (package
-            index).
-        :param password:
-            The password used to authenticate to the repository (package
-            index).
-        :param non_interactive:
-            Do not interactively prompt for username/password if the required
-            credentials are missing.
-        :param comment:
-            The comment to include with each distribution file.
-        :param config_file:
-            The path to the configuration file to use.
-        :param skip_existing:
-            Specify whether twine should continue uploading files if one
-            of them already exists. This primarily supports PyPI. Other
-            package indexes may not be supported.
-        :param cacert:
-            The path to the bundle of certificates used to verify the TLS
-            connection to the package index.
-        :param client_cert:
-            The path to the client certificate used to perform authentication to the
-            index. This must be a single file that contains both the private key and
-            the PEM-encoded certificate.
-        :param repository_name:
-            The name of the repository (package index) to interact with. This
-            should correspond to a section in the config file.
-        :param repository_url:
-            The URL of the repository (package index) to interact with. This
-            will override the settings inferred from ``repository_name``.
-        :param verbose:
-            Show verbose output.
-        :param disable_progress_bar:
-            Disable the progress bar.
-        """
-        self.config_file = config_file
-        self.comment = comment
-        self.verbose = verbose
-        self.disable_progress_bar = disable_progress_bar
-        self.skip_existing = skip_existing
-        self._handle_repository_options(
-            repository_name=repository_name,
-            repository_url=repository_url,
-        )
-        self.attestations = attestations
-        self._handle_package_signing(
-            sign=sign,
-            sign_with=sign_with,
-            identity=identity,
-        )
-        # _handle_certificates relies on the parsed repository config
-        self._handle_certificates(cacert, client_cert)
-        self.auth = auth.Resolver.choose(not non_interactive)(
-            self.repository_config,
-            auth.CredentialInput(username, password),
-        )
-
-    @property
-    def username(self) -> Optional[str]:
-        return self.auth.username
-
-    @property
-    def password(self) -> Optional[str]:
-        with self._allow_noninteractive():
-            return self.auth.password
-
-    def _allow_noninteractive(self) -> "contextlib.AbstractContextManager[None]":
-        """Bypass NonInteractive error when client cert is present."""
-        suppressed = (exceptions.NonInteractive,) if self.client_cert else ()
-        return contextlib.suppress(*suppressed)
-
-    @property
-    def verbose(self) -> bool:
-        return self._verbose
-
-    @verbose.setter
-    def verbose(self, verbose: bool) -> None:
-        """Initialize a logger based on the --verbose option."""
-        self._verbose = verbose
-        twine_logger = logging.getLogger("twine")
-        twine_logger.setLevel(logging.INFO if verbose else logging.WARNING)
-
-    @staticmethod
-    def register_argparse_arguments(parser: argparse.ArgumentParser) -> None:
-        """Register the arguments for argparse."""
-        parser.add_argument(
-            "-r",
-            "--repository",
-            action=utils.EnvironmentDefault,
-            env="TWINE_REPOSITORY",
-            default="pypi",
-            help="The repository (package index) to upload the package to. "
-            "Should be a section in the config file [default: "
-            "%(default)s]. (Can also be set via %(env)s environment "
-            "variable.)",
-        )
-        parser.add_argument(
-            "--repository-url",
-            action=utils.EnvironmentDefault,
-            env="TWINE_REPOSITORY_URL",
-            default=None,
-            required=False,
-            help="The repository (package index) URL to upload the package to."
-            " This overrides --repository. "
-            "(Can also be set via %(env)s environment variable.)",
-        )
-        parser.add_argument(
-            "--attestations",
-            action="store_true",
-            default=False,
-            help="Upload each file's associated attestations.",
-        )
-        parser.add_argument(
-            "-s",
-            "--sign",
-            action="store_true",
-            default=False,
-            help="Sign files to upload using GPG.",
-        )
-        parser.add_argument(
-            "--sign-with",
-            default="gpg",
-            help="GPG program used to sign uploads [default: %(default)s].",
-        )
-        parser.add_argument(
-            "-i",
-            "--identity",
-            help="GPG identity used to sign files.",
-        )
-        parser.add_argument(
-            "-u",
-            "--username",
-            action=utils.EnvironmentDefault,
-            env="TWINE_USERNAME",
-            required=False,
-            help="The username to authenticate to the repository "
-            "(package index) as. Has no effect on PyPI or TestPyPI. "
-            "(Can also be set via %(env)s environment variable.)",
-        )
-        parser.add_argument(
-            "-p",
-            "--password",
-            action=utils.EnvironmentDefault,
-            env="TWINE_PASSWORD",
-            required=False,
-            help="The password to authenticate to the repository "
-            "(package index) with. (Can also be set via "
-            "%(env)s environment variable.)",
-        )
-        parser.add_argument(
-            "--non-interactive",
-            action=utils.EnvironmentFlag,
-            env="TWINE_NON_INTERACTIVE",
-            help="Do not interactively prompt for username/password if the "
-            "required credentials are missing. (Can also be set via "
-            "%(env)s environment variable.)",
-        )
-        parser.add_argument(
-            "-c",
-            "--comment",
-            help="The comment to include with the distribution file.",
-        )
-        parser.add_argument(
-            "--config-file",
-            default=utils.DEFAULT_CONFIG_FILE,
-            help="The .pypirc config file to use.",
-        )
-        parser.add_argument(
-            "--skip-existing",
-            default=False,
-            action="store_true",
-            help="Continue uploading files if one already exists. (Only valid "
-            "when uploading to PyPI. Other implementations may not "
-            "support this.)",
-        )
-        parser.add_argument(
-            "--cert",
-            action=utils.EnvironmentDefault,
-            env="TWINE_CERT",
-            default=None,
-            required=False,
-            metavar="path",
-            help="Path to alternate CA bundle (can also be set via %(env)s "
-            "environment variable).",
-        )
-        parser.add_argument(
-            "--client-cert",
-            metavar="path",
-            help="Path to SSL client certificate, a single file containing the"
-            " private key and the certificate in PEM format.",
-        )
-        parser.add_argument(
-            "--verbose",
-            default=False,
-            required=False,
-            action="store_true",
-            help="Show verbose output.",
-        )
-        parser.add_argument(
-            "--disable-progress-bar",
-            default=False,
-            required=False,
-            action="store_true",
-            help="Disable the progress bar.",
-        )
-
-    @classmethod
-    def from_argparse(cls, args: argparse.Namespace) -> "Settings":
-        """Generate the Settings from parsed arguments."""
-        settings = vars(args)
-        settings["repository_name"] = settings.pop("repository")
-        settings["cacert"] = settings.pop("cert")
-        return cls(**settings)
-
-    def _handle_package_signing(
-        self, sign: bool, sign_with: str, identity: Optional[str]
-    ) -> None:
-        if not sign and identity:
-            raise exceptions.InvalidSigningConfiguration(
-                "sign must be given along with identity"
-            )
-        self.sign = sign
-        self.sign_with = sign_with
-        self.identity = identity
-
-    def _handle_repository_options(
-        self, repository_name: str, repository_url: Optional[str]
-    ) -> None:
-        self.repository_config = utils.get_repository_from_config(
-            self.config_file,
-            repository_name,
-            repository_url,
-        )
-
-    def _handle_certificates(
-        self, cacert: Optional[str], client_cert: Optional[str]
-    ) -> None:
-        self.cacert = utils.get_cacert(cacert, self.repository_config)
-        self.client_cert = utils.get_clientcert(client_cert, self.repository_config)
-
-    def verify_feature_capability(self) -> None:
-        """Verify configured settings are supported for the configured repository.
-
-        This presently checks:
-        - ``--skip-existing`` was only provided for PyPI and TestPyPI
-
-        :raises twine.exceptions.UnsupportedConfiguration:
-            The configured features are not available with the configured
-            repository.
-        """
-        repository_url = cast(str, self.repository_config["repository"])
-
-        if self.skip_existing and not repository_url.startswith(
-            (repository.WAREHOUSE, repository.TEST_WAREHOUSE)
-        ):
-            raise exceptions.UnsupportedConfiguration.Builder().with_feature(
-                "--skip-existing"
-            ).with_repository_url(repository_url).finalize()
-
-    def check_repository_url(self) -> None:
-        """Verify we are not using legacy PyPI.
-
-        :raises twine.exceptions.UploadToDeprecatedPyPIDetected:
-            The configured repository URL is for legacy PyPI.
-        """
-        repository_url = cast(str, self.repository_config["repository"])
-
-        if repository_url.startswith(
-            (repository.LEGACY_PYPI, repository.LEGACY_TEST_PYPI)
-        ):
-            raise exceptions.UploadToDeprecatedPyPIDetected.from_args(
-                repository_url, utils.DEFAULT_REPOSITORY, utils.TEST_REPOSITORY
-            )
-
-    def create_repository(self) -> repository.Repository:
-        """Create a new repository for uploading."""
-        repo = repository.Repository(
-            cast(str, self.repository_config["repository"]),
-            self.username,
-            self.password,
-            self.disable_progress_bar,
-        )
-        repo.set_certificate_authority(self.cacert)
-        repo.set_client_certificate(self.client_cert)
-        return repo