golden hour

/opt/alt/python37/lib/python3.7/site-packages/pip/_internal/utils

File/Folder	Size	Actions
__init__.py	0 B
__init__.pyc	164 B
__init__.pyo	164 B
__pycache__	-
appdirs.py	1.32 KB
appdirs.pyc	1.78 KB
appdirs.pyo	1.78 KB
compat.py	9.27 KB
compat.pyc	8.62 KB
compat.pyo	8.62 KB
compatibility_tags.py	5.31 KB
compatibility_tags.pyc	4.45 KB
compatibility_tags.pyo	4.45 KB
datetime.py	295 B
datetime.pyc	625 B
datetime.pyo	625 B
deprecation.py	3.24 KB
deprecation.pyc	3.44 KB
deprecation.pyo	3.44 KB
direct_url_helpers.py	4.26 KB
direct_url_helpers.pyc	3.37 KB
direct_url_helpers.pyo	3.24 KB
distutils_args.py	1.32 KB
distutils_args.pyc	1.6 KB
distutils_args.pyo	1.6 KB
encoding.py	1.25 KB
encoding.pyc	1.61 KB
encoding.pyo	1.56 KB
entrypoints.py	1.19 KB
entrypoints.pyc	1.47 KB
entrypoints.pyo	1.47 KB
filesystem.py	6.78 KB
filesystem.pyc	7.4 KB
filesystem.pyo	7.35 KB
filetypes.py	571 B
filetypes.pyc	792 B
filetypes.pyo	792 B
glibc.py	3.22 KB
glibc.pyc	2.19 KB
glibc.pyo	2.19 KB
hashes.py	4.57 KB
hashes.pyc	5.68 KB
hashes.pyo	5.68 KB
inject_securetransport.py	810 B
inject_securetransport.pyc	1.07 KB
inject_securetransport.pyo	1.07 KB
logging.py	12.79 KB
logging.pyc	11.6 KB
logging.pyo	11.6 KB
misc.py	27.67 KB
misc.pyc	32.2 KB
misc.pyo	32.2 KB
models.py	1.17 KB
models.pyc	2.55 KB
models.pyo	2.55 KB
packaging.py	2.96 KB
packaging.pyc	3.27 KB
packaging.pyo	3.27 KB
parallel.py	3.32 KB
parallel.pyc	3.62 KB
parallel.pyo	3.62 KB
pkg_resources.py	1.22 KB
pkg_resources.pyc	2.39 KB
pkg_resources.pyo	2.39 KB
setuptools_build.py	4.94 KB
setuptools_build.pyc	3.83 KB
setuptools_build.pyo	3.75 KB
subprocess.py	9.69 KB
subprocess.pyc	6.77 KB
subprocess.pyo	6.69 KB
temp_dir.py	8.18 KB
temp_dir.pyc	8.75 KB
temp_dir.pyo	8.62 KB
typing.py	1.37 KB
typing.pyc	1.52 KB
typing.pyo	1.52 KB
unpacking.py	9.27 KB
unpacking.pyc	7.83 KB
unpacking.pyo	7.79 KB
urls.py	1.49 KB
urls.pyc	1.94 KB
urls.pyo	1.8 KB
virtualenv.py	3.62 KB
virtualenv.pyc	4.11 KB
virtualenv.pyo	4.11 KB
wheel.py	7.13 KB
wheel.pyc	7.27 KB
wheel.pyo	7.27 KB

Edit: hashes.py

from __future__ import absolute_import

import hashlib

from pip._vendor.six import iteritems, iterkeys, itervalues

from pip._internal.exceptions import (
    HashMismatch,
    HashMissing,
    InstallationError,
)
from pip._internal.utils.misc import read_chunks
from pip._internal.utils.typing import MYPY_CHECK_RUNNING

if MYPY_CHECK_RUNNING:
    from typing import (
        Dict, List, BinaryIO, NoReturn, Iterator
    )
    from pip._vendor.six import PY3
    if PY3:
        from hashlib import _Hash
    else:
        from hashlib import _hash as _Hash

# The recommended hash algo of the moment. Change this whenever the state of
# the art changes; it won't hurt backward compatibility.
FAVORITE_HASH = 'sha256'

# Names of hashlib algorithms allowed by the --hash option and ``pip hash``
# Currently, those are the ones at least as collision-resistant as sha256.
STRONG_HASHES = ['sha256', 'sha384', 'sha512']

class Hashes(object):
    """A wrapper that builds multiple hashes at once and checks them against
    known-good values

"""
    def __init__(self, hashes=None):
        # type: (Dict[str, List[str]]) -> None
        """
        :param hashes: A dict of algorithm names pointing to lists of allowed
            hex digests
        """
        self._allowed = {} if hashes is None else hashes

def __and__(self, other):
        # type: (Hashes) -> Hashes
        if not isinstance(other, Hashes):
            return NotImplemented

# If either of the Hashes object is entirely empty (i.e. no hash
        # specified at all), all hashes from the other object are allowed.
        if not other:
            return self
        if not self:
            return other

# Otherwise only hashes that present in both objects are allowed.
        new = {}
        for alg, values in iteritems(other._allowed):
            if alg not in self._allowed:
                continue
            new[alg] = [v for v in values if v in self._allowed[alg]]
        return Hashes(new)

@property
    def digest_count(self):
        # type: () -> int
        return sum(len(digests) for digests in self._allowed.values())

def is_hash_allowed(
        self,
        hash_name,   # type: str
        hex_digest,  # type: str
    ):
        # type: (...) -> bool
        """Return whether the given hex digest is allowed."""
        return hex_digest in self._allowed.get(hash_name, [])

def check_against_chunks(self, chunks):
        # type: (Iterator[bytes]) -> None
        """Check good hashes against ones built from iterable of chunks of
        data.

Raise HashMismatch if none match.

"""
        gots = {}
        for hash_name in iterkeys(self._allowed):
            try:
                gots[hash_name] = hashlib.new(hash_name)
            except (ValueError, TypeError):
                raise InstallationError(
                    'Unknown hash name: {}'.format(hash_name)
                )

for chunk in chunks:
            for hash in itervalues(gots):
                hash.update(chunk)

for hash_name, got in iteritems(gots):
            if got.hexdigest() in self._allowed[hash_name]:
                return
        self._raise(gots)

def _raise(self, gots):
        # type: (Dict[str, _Hash]) -> NoReturn
        raise HashMismatch(self._allowed, gots)

def check_against_file(self, file):
        # type: (BinaryIO) -> None
        """Check good hashes against a file-like object

Raise HashMismatch if none match.

"""
        return self.check_against_chunks(read_chunks(file))

def check_against_path(self, path):
        # type: (str) -> None
        with open(path, 'rb') as file:
            return self.check_against_file(file)

def __nonzero__(self):
        # type: () -> bool
        """Return whether I know any known-good hashes."""
        return bool(self._allowed)

def __bool__(self):
        # type: () -> bool
        return self.__nonzero__()

class MissingHashes(Hashes):
    """A workalike for Hashes used when we're missing a hash for a requirement

It computes the actual hash of the requirement and raises a HashMissing
    exception showing it to the user.

"""
    def __init__(self):
        # type: () -> None
        """Don't offer the ``hashes`` kwarg."""
        # Pass our favorite hash in to generate a "gotten hash". With the
        # empty list, it will never match, so an error will always raise.
        super(MissingHashes, self).__init__(hashes={FAVORITE_HASH: []})

def _raise(self, gots):
        # type: (Dict[str, _Hash]) -> NoReturn
        raise HashMissing(gots[FAVORITE_HASH].hexdigest())