SEC [ helpsmego.digital ]

Linux premium110.web-hosting.com 4.18.0-553.84.1.lve.el8.x86_64 #1 SMP Tue Nov 25 18:33:03 UTC 2025 x86_64

LiteSpeed

199.188.201.155 | Your IP: 216.73.216.6

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ opt / cloudlinux / venv / lib / python3.11 / site-packages / pip / _internal / utils /

Home Upload Mass Deface Mass Delete Back Connect Info Server

Server Info

Operating System	:	Linux premium110.web-hosting.com 4.18.0-553.84.1.lve.el8.x86_64 #1 SMP Tue Nov 25 18:33:03 UTC 2025 x86_64
User / Group	:	2062[decaawyr] / 2057[decaawyr]
PHP Version	:	7.4.33
IP Server	:	199.188.201.155
Your IP	:	216.73.216.6
Storage	:	Total = 48.91 GB, Free = 32.49 GB [66%]
Domains	:	Cant read [ /etc/named.conf ]
Software	:	LiteSpeed
Disable Functions	:	All function is accessible
Useful Functions	:	gcc, lcc, cc, ld, make, php, perl, python, ruby, tar, gzip, bzip, bzialfa2, nc, locate, suidperl, git, docker, ssh
Downloader	:	wget, fetch, lynx, links, curl, get, lwp-mirror
CURL : ON \| SSH2 : OFF \| Magic Quotes : ON \| MySQL : ON \| MSSQL : OFF \| PostgreSQL : ON \| Oracle : OFF
Safe Mode : OFF \| Open Basedir : NONE \| Safe Mode Exec Dir : NONE \| Safe Mode Include Dir : NONE

hashes.py

from __future__ import annotations

import hashlib
from collections.abc import Iterable
from typing import TYPE_CHECKING, BinaryIO, NoReturn

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: dict[str, list[str]] | None = 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())

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2026-02-05 08:03:12
..	dir	-	root/root	drwxr-xr-x	2026-02-05 08:01:30
__pycache__	dir	-	root/root	drwxr-xr-x	2026-02-05 08:03:12
__init__.py	application/x-empty	0 B	root/root	-rw-r--r--	2026-01-20 01:01:47
_jaraco_text.py	text/plain	3.27 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
_log.py	text/plain	1015 B	root/root	-rw-r--r--	2026-01-20 01:01:47
appdirs.py	text/plain	1.64 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
compat.py	text/plain	2.46 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
compatibility_tags.py	text/plain	6.47 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
datetime.py	text/plain	241 B	root/root	-rw-r--r--	2026-01-20 01:01:47
deprecation.py	text/plain	3.61 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
direct_url_helpers.py	text/x-python	3.13 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
egg_link.py	text/x-python	2.4 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
entrypoints.py	text/x-python	3.25 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
filesystem.py	text/x-python	5.37 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
filetypes.py	text/plain	689 B	root/root	-rw-r--r--	2026-01-20 01:01:47
glibc.py	text/x-python	3.64 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
hashes.py	text/x-python	4.88 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
logging.py	text/x-python	11.82 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
misc.py	text/x-python	22.83 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
packaging.py	text/x-python	1.56 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
retry.py	text/x-python	1.43 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
subprocess.py	text/x-python	8.77 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
temp_dir.py	text/x-python	9.09 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
unpacking.py	text/plain	12.67 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
urls.py	text/x-python	1.56 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
virtualenv.py	text/x-python	3.37 KB	root/root	-rw-r--r--	2026-01-20 01:01:47
wheel.py	text/plain	4.36 KB	root/root	-rw-r--r--	2026-01-20 01:01:47