Graybyt3 Was Here

Linux host74.registrar-servers.com 4.18.0-553.lve.el8.x86_64 #1 SMP Mon May 27 15:27:34 UTC 2024 x86_64
Apache
162.213.253.119

File Name : requirements.py

from pip._vendor.packaging.utils import canonicalize_name

from pip._internal.utils.typing import MYPY_CHECK_RUNNING

from .base import Requirement, format_name

if MYPY_CHECK_RUNNING:
    from pip._vendor.packaging.specifiers import SpecifierSet

from pip._internal.req.req_install import InstallRequirement

from .base import Candidate, CandidateLookup

class ExplicitRequirement(Requirement):
    def __init__(self, candidate):
        # type: (Candidate) -> None
        self.candidate = candidate

def __repr__(self):
        # type: () -> str
        return "{class_name}({candidate!r})".format(
            class_name=self.__class__.__name__,
            candidate=self.candidate,
        )

@property
    def name(self):
        # type: () -> str
        # No need to canonicalise - the candidate did this
        return self.candidate.name

def format_for_error(self):
        # type: () -> str
        return self.candidate.format_for_error()

def get_candidate_lookup(self):
        # type: () -> CandidateLookup
        return self.candidate, None

def is_satisfied_by(self, candidate):
        # type: (Candidate) -> bool
        return candidate == self.candidate

class SpecifierRequirement(Requirement):
    def __init__(self, ireq):
        # type: (InstallRequirement) -> None
        assert ireq.link is None, "This is a link, not a specifier"
        self._ireq = ireq
        self._extras = frozenset(ireq.extras)

def __str__(self):
        # type: () -> str
        return str(self._ireq.req)

def __repr__(self):
        # type: () -> str
        return "{class_name}({requirement!r})".format(
            class_name=self.__class__.__name__,
            requirement=str(self._ireq.req),
        )

@property
    def name(self):
        # type: () -> str
        canonical_name = canonicalize_name(self._ireq.req.name)
        return format_name(canonical_name, self._extras)

def format_for_error(self):
        # type: () -> str

# Convert comma-separated specifiers into "A, B, ..., F and G"
        # This makes the specifier a bit more "human readable", without
        # risking a change in meaning. (Hopefully! Not all edge cases have
        # been checked)
        parts = [s.strip() for s in str(self).split(",")]
        if len(parts) == 0:
            return ""
        elif len(parts) == 1:
            return parts[0]

return ", ".join(parts[:-1]) + " and " + parts[-1]

def get_candidate_lookup(self):
        # type: () -> CandidateLookup
        return None, self._ireq

def is_satisfied_by(self, candidate):
        # type: (Candidate) -> bool
        assert candidate.name == self.name, \
            "Internal issue: Candidate is not for this requirement " \
            " {} vs {}".format(candidate.name, self.name)
        # We can safely always allow prereleases here since PackageFinder
        # already implements the prerelease logic, and would have filtered out
        # prerelease candidates if the user does not expect them.
        spec = self._ireq.req.specifier
        return spec.contains(candidate.version, prereleases=True)

class RequiresPythonRequirement(Requirement):
    """A requirement representing Requires-Python metadata.
    """
    def __init__(self, specifier, match):
        # type: (SpecifierSet, Candidate) -> None
        self.specifier = specifier
        self._candidate = match

def __repr__(self):
        # type: () -> str
        return "{class_name}({specifier!r})".format(
            class_name=self.__class__.__name__,
            specifier=str(self.specifier),
        )

@property
    def name(self):
        # type: () -> str
        return self._candidate.name

def format_for_error(self):
        # type: () -> str
        return "Python " + str(self.specifier)

def get_candidate_lookup(self):
        # type: () -> CandidateLookup
        if self.specifier.contains(self._candidate.version, prereleases=True):
            return self._candidate, None
        return None, None

def is_satisfied_by(self, candidate):
        # type: (Candidate) -> bool
        assert candidate.name == self._candidate.name, "Not Python candidate"
        # We can safely always allow prereleases here since PackageFinder
        # already implements the prerelease logic, and would have filtered out
        # prerelease candidates if the user does not expect them.
        return self.specifier.contains(candidate.version, prereleases=True)

System Information
*ReClick For Close
File : BlackDragon /wp-content/uploads/2019/09/hq95bs/index.php

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	0755	2024-03-29 09:07:14
..	dir	-	root/linksafe	0755	2024-03-29 09:07:14
__init__.py	application/x-empty	0 B	root/linksafe	0644	2023-11-13 09:11:11
__init__.pyc	application/octet-stream	242 B	root/linksafe	0644	2023-11-13 09:11:11
base.py	text/x-python	3.37 KB	root/linksafe	0644	2023-11-13 09:11:11
base.pyc	application/octet-stream	7.92 KB	root/linksafe	0644	2023-11-13 09:11:11
candidates.py	text/x-python	19.79 KB	root/linksafe	0644	2023-11-13 09:11:11
candidates.pyc	application/octet-stream	26.68 KB	root/linksafe	0644	2023-11-13 09:11:11
factory.py	text/x-python	16.49 KB	root/linksafe	0644	2023-11-13 09:11:11
factory.pyc	application/octet-stream	14.95 KB	root/linksafe	0644	2023-11-13 09:11:11
found_candidates.py	text/x-python	3.48 KB	root/linksafe	0644	2023-11-13 09:11:11
found_candidates.pyc	application/octet-stream	4.73 KB	root/linksafe	0644	2023-11-13 09:11:11
provider.py	text/x-python	3.96 KB	root/linksafe	0644	2023-11-13 09:11:11
provider.pyc	application/octet-stream	4.48 KB	root/linksafe	0644	2023-11-13 09:11:11
requirements.py	text/x-python	4.41 KB	root/linksafe	0644	2023-11-13 09:11:11
requirements.pyc	application/octet-stream	8.06 KB	root/linksafe	0644	2023-11-13 09:11:11
resolver.py	text/x-python	9.86 KB	root/linksafe	0644	2023-11-13 09:11:11
resolver.pyc	application/octet-stream	8.77 KB	root/linksafe	0644	2023-11-13 09:11:11