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

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

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

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

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