ACIL FM

Nama	Ukuran	Aksi
__pycache__	-	Open
appdirs.py	1.67 MB	View DL Edit
compat.py	2.34 MB	View DL Edit
compatibility_tags.py	6.51 MB	View DL Edit
datetime.py	241 B	View DL Edit
deprecation.py	3.62 MB	View DL Edit
direct_url_helpers.py	3.12 MB	View DL Edit
egg_link.py	2.41 MB	View DL Edit
entrypoints.py	3.25 MB	View DL Edit
filesystem.py	4.83 MB	View DL Edit
filetypes.py	715 B	View DL Edit
glibc.py	3.65 MB	View DL Edit
hashes.py	4.86 MB	View DL Edit
logging.py	11.79 MB	View DL Edit
misc.py	22.9 MB	View DL Edit
packaging.py	1.57 MB	View DL Edit
retry.py	1.36 MB	View DL Edit
setuptools_build.py	4.38 MB	View DL Edit
subprocess.py	8.78 MB	View DL Edit
temp_dir.py	9.09 MB	View DL Edit
unpacking.py	11.65 MB	View DL Edit
urls.py	1.56 MB	View DL Edit
virtualenv.py	3.38 MB	View DL Edit
wheel.py	4.39 MB	View DL Edit
_jaraco_text.py	3.27 MB	View DL Edit
_log.py	1015 B	View DL Edit
__init__.py	0 B	View DL Edit

Edit file: /opt/imunify360/venv/lib/python3.11/site-packages/pip/_internal/utils/hashes.py

import hashlib
from typing import TYPE_CHECKING, BinaryIO, Dict, Iterable, List, NoReturn, Optional

from pip._internal.exceptions import HashMismatch, HashMissing, InstallationError
from pip._internal.utils.misc import read_chunks

if TYPE_CHECKING:
    from hashlib import _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:
    """A wrapper that builds multiple hashes at once and checks them against
    known-good values

"""

def __init__(self, hashes: Optional[Dict[str, List[str]]] = None) -> None:
        """
        :param hashes: A dict of algorithm names pointing to lists of allowed
            hex digests
        """
        allowed = {}
        if hashes is not None:
            for alg, keys in hashes.items():
                # Make sure values are always sorted (to ease equality checks)
                allowed[alg] = [k.lower() for k in sorted(keys)]
        self._allowed = allowed

def __and__(self, other: "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 other._allowed.items():
            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) -> int:
        return sum(len(digests) for digests in self._allowed.values())

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

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

Raise HashMismatch if none match.

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

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

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

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

def check_against_file(self, file: 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: str) -> None:
        with open(path, "rb") as file:
            return self.check_against_file(file)

def has_one_of(self, hashes: Dict[str, str]) -> bool:
        """Return whether any of the given hashes are allowed."""
        for hash_name, hex_digest in hashes.items():
            if self.is_hash_allowed(hash_name, hex_digest):
                return True
        return False

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

def __eq__(self, other: object) -> bool:
        if not isinstance(other, Hashes):
            return NotImplemented
        return self._allowed == other._allowed

def __hash__(self) -> int:
        return hash(
            ",".join(
                sorted(
                    ":".join((alg, digest))
                    for alg, digest_list in self._allowed.items()
                    for digest in digest_list
                )
            )
        )

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) -> 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().__init__(hashes={FAVORITE_HASH: []})

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

Batal