Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 88
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 218
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 219
Warning: Cannot modify header information - headers already sent by (output started at /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php:88) in /home/afelisqd/cppseducation.sc.tz/admin/images/photos/17587263121019776732_admin-dbb.php on line 220
PK ! ȽZ serialize.pynu [ import base64
import io
import json
import zlib
from pip._vendor import msgpack
from pip._vendor.requests.structures import CaseInsensitiveDict
from .compat import HTTPResponse, pickle, text_type
def _b64_decode_bytes(b):
return base64.b64decode(b.encode("ascii"))
def _b64_decode_str(s):
return _b64_decode_bytes(s).decode("utf8")
class Serializer(object):
def dumps(self, request, response, body=None):
response_headers = CaseInsensitiveDict(response.headers)
if body is None:
body = response.read(decode_content=False)
# NOTE: 99% sure this is dead code. I'm only leaving it
# here b/c I don't have a test yet to prove
# it. Basically, before using
# `cachecontrol.filewrapper.CallbackFileWrapper`,
# this made an effort to reset the file handle. The
# `CallbackFileWrapper` short circuits this code by
# setting the body as the content is consumed, the
# result being a `body` argument is *always* passed
# into cache_response, and in turn,
# `Serializer.dump`.
response._fp = io.BytesIO(body)
# NOTE: This is all a bit weird, but it's really important that on
# Python 2.x these objects are unicode and not str, even when
# they contain only ascii. The problem here is that msgpack
# understands the difference between unicode and bytes and we
# have it set to differentiate between them, however Python 2
# doesn't know the difference. Forcing these to unicode will be
# enough to have msgpack know the difference.
data = {
u"response": {
u"body": body,
u"headers": dict(
(text_type(k), text_type(v)) for k, v in response.headers.items()
),
u"status": response.status,
u"version": response.version,
u"reason": text_type(response.reason),
u"strict": response.strict,
u"decode_content": response.decode_content,
}
}
# Construct our vary headers
data[u"vary"] = {}
if u"vary" in response_headers:
varied_headers = response_headers[u"vary"].split(",")
for header in varied_headers:
header = text_type(header).strip()
header_value = request.headers.get(header, None)
if header_value is not None:
header_value = text_type(header_value)
data[u"vary"][header] = header_value
return b",".join([b"cc=4", msgpack.dumps(data, use_bin_type=True)])
def loads(self, request, data):
# Short circuit if we've been given an empty set of data
if not data:
return
# Determine what version of the serializer the data was serialized
# with
try:
ver, data = data.split(b",", 1)
except ValueError:
ver = b"cc=0"
# Make sure that our "ver" is actually a version and isn't a false
# positive from a , being in the data stream.
if ver[:3] != b"cc=":
data = ver + data
ver = b"cc=0"
# Get the version number out of the cc=N
ver = ver.split(b"=", 1)[-1].decode("ascii")
# Dispatch to the actual load method for the given version
try:
return getattr(self, "_loads_v{}".format(ver))(request, data)
except AttributeError:
# This is a version we don't have a loads function for, so we'll
# just treat it as a miss and return None
return
def prepare_response(self, request, cached):
"""Verify our vary headers match and construct a real urllib3
HTTPResponse object.
"""
# Special case the '*' Vary value as it means we cannot actually
# determine if the cached response is suitable for this request.
# This case is also handled in the controller code when creating
# a cache entry, but is left here for backwards compatibility.
if "*" in cached.get("vary", {}):
return
# Ensure that the Vary headers for the cached response match our
# request
for header, value in cached.get("vary", {}).items():
if request.headers.get(header, None) != value:
return
body_raw = cached["response"].pop("body")
headers = CaseInsensitiveDict(data=cached["response"]["headers"])
if headers.get("transfer-encoding", "") == "chunked":
headers.pop("transfer-encoding")
cached["response"]["headers"] = headers
try:
body = io.BytesIO(body_raw)
except TypeError:
# This can happen if cachecontrol serialized to v1 format (pickle)
# using Python 2. A Python 2 str(byte string) will be unpickled as
# a Python 3 str (unicode string), which will cause the above to
# fail with:
#
# TypeError: 'str' does not support the buffer interface
body = io.BytesIO(body_raw.encode("utf8"))
return HTTPResponse(body=body, preload_content=False, **cached["response"])
def _loads_v0(self, request, data):
# The original legacy cache data. This doesn't contain enough
# information to construct everything we need, so we'll treat this as
# a miss.
return
def _loads_v1(self, request, data):
try:
cached = pickle.loads(data)
except ValueError:
return
return self.prepare_response(request, cached)
def _loads_v2(self, request, data):
try:
cached = json.loads(zlib.decompress(data).decode("utf8"))
except (ValueError, zlib.error):
return
# We need to decode the items that we've base64 encoded
cached["response"]["body"] = _b64_decode_bytes(cached["response"]["body"])
cached["response"]["headers"] = dict(
(_b64_decode_str(k), _b64_decode_str(v))
for k, v in cached["response"]["headers"].items()
)
cached["response"]["reason"] = _b64_decode_str(cached["response"]["reason"])
cached["vary"] = dict(
(_b64_decode_str(k), _b64_decode_str(v) if v is not None else v)
for k, v in cached["vary"].items()
)
return self.prepare_response(request, cached)
def _loads_v3(self, request, data):
# Due to Python 2 encoding issues, it's impossible to know for sure
# exactly how to load v3 entries, thus we'll treat these as a miss so
# that they get rewritten out as v4 entries.
return
def _loads_v4(self, request, data):
try:
cached = msgpack.loads(data, raw=False)
except ValueError:
return
return self.prepare_response(request, cached)
PK ! omE7 E7
controller.pynu [ """
The httplib2 algorithms ported for use with requests.
"""
import logging
import re
import calendar
import time
from email.utils import parsedate_tz
from pip._vendor.requests.structures import CaseInsensitiveDict
from .cache import DictCache
from .serialize import Serializer
logger = logging.getLogger(__name__)
URI = re.compile(r"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?")
def parse_uri(uri):
"""Parses a URI using the regex given in Appendix B of RFC 3986.
(scheme, authority, path, query, fragment) = parse_uri(uri)
"""
groups = URI.match(uri).groups()
return (groups[1], groups[3], groups[4], groups[6], groups[8])
class CacheController(object):
"""An interface to see if request should cached or not.
"""
def __init__(
self, cache=None, cache_etags=True, serializer=None, status_codes=None
):
self.cache = DictCache() if cache is None else cache
self.cache_etags = cache_etags
self.serializer = serializer or Serializer()
self.cacheable_status_codes = status_codes or (200, 203, 300, 301)
@classmethod
def _urlnorm(cls, uri):
"""Normalize the URL to create a safe key for the cache"""
(scheme, authority, path, query, fragment) = parse_uri(uri)
if not scheme or not authority:
raise Exception("Only absolute URIs are allowed. uri = %s" % uri)
scheme = scheme.lower()
authority = authority.lower()
if not path:
path = "/"
# Could do syntax based normalization of the URI before
# computing the digest. See Section 6.2.2 of Std 66.
request_uri = query and "?".join([path, query]) or path
defrag_uri = scheme + "://" + authority + request_uri
return defrag_uri
@classmethod
def cache_url(cls, uri):
return cls._urlnorm(uri)
def parse_cache_control(self, headers):
known_directives = {
# https://tools.ietf.org/html/rfc7234#section-5.2
"max-age": (int, True),
"max-stale": (int, False),
"min-fresh": (int, True),
"no-cache": (None, False),
"no-store": (None, False),
"no-transform": (None, False),
"only-if-cached": (None, False),
"must-revalidate": (None, False),
"public": (None, False),
"private": (None, False),
"proxy-revalidate": (None, False),
"s-maxage": (int, True),
}
cc_headers = headers.get("cache-control", headers.get("Cache-Control", ""))
retval = {}
for cc_directive in cc_headers.split(","):
if not cc_directive.strip():
continue
parts = cc_directive.split("=", 1)
directive = parts[0].strip()
try:
typ, required = known_directives[directive]
except KeyError:
logger.debug("Ignoring unknown cache-control directive: %s", directive)
continue
if not typ or not required:
retval[directive] = None
if typ:
try:
retval[directive] = typ(parts[1].strip())
except IndexError:
if required:
logger.debug(
"Missing value for cache-control " "directive: %s",
directive,
)
except ValueError:
logger.debug(
"Invalid value for cache-control directive " "%s, must be %s",
directive,
typ.__name__,
)
return retval
def cached_request(self, request):
"""
Return a cached response if it exists in the cache, otherwise
return False.
"""
cache_url = self.cache_url(request.url)
logger.debug('Looking up "%s" in the cache', cache_url)
cc = self.parse_cache_control(request.headers)
# Bail out if the request insists on fresh data
if "no-cache" in cc:
logger.debug('Request header has "no-cache", cache bypassed')
return False
if "max-age" in cc and cc["max-age"] == 0:
logger.debug('Request header has "max_age" as 0, cache bypassed')
return False
# Request allows serving from the cache, let's see if we find something
cache_data = self.cache.get(cache_url)
if cache_data is None:
logger.debug("No cache entry available")
return False
# Check whether it can be deserialized
resp = self.serializer.loads(request, cache_data)
if not resp:
logger.warning("Cache entry deserialization failed, entry ignored")
return False
# If we have a cached 301, return it immediately. We don't
# need to test our response for other headers b/c it is
# intrinsically "cacheable" as it is Permanent.
# See:
# https://tools.ietf.org/html/rfc7231#section-6.4.2
#
# Client can try to refresh the value by repeating the request
# with cache busting headers as usual (ie no-cache).
if resp.status == 301:
msg = (
'Returning cached "301 Moved Permanently" response '
"(ignoring date and etag information)"
)
logger.debug(msg)
return resp
headers = CaseInsensitiveDict(resp.headers)
if not headers or "date" not in headers:
if "etag" not in headers:
# Without date or etag, the cached response can never be used
# and should be deleted.
logger.debug("Purging cached response: no date or etag")
self.cache.delete(cache_url)
logger.debug("Ignoring cached response: no date")
return False
now = time.time()
date = calendar.timegm(parsedate_tz(headers["date"]))
current_age = max(0, now - date)
logger.debug("Current age based on date: %i", current_age)
# TODO: There is an assumption that the result will be a
# urllib3 response object. This may not be best since we
# could probably avoid instantiating or constructing the
# response until we know we need it.
resp_cc = self.parse_cache_control(headers)
# determine freshness
freshness_lifetime = 0
# Check the max-age pragma in the cache control header
if "max-age" in resp_cc:
freshness_lifetime = resp_cc["max-age"]
logger.debug("Freshness lifetime from max-age: %i", freshness_lifetime)
# If there isn't a max-age, check for an expires header
elif "expires" in headers:
expires = parsedate_tz(headers["expires"])
if expires is not None:
expire_time = calendar.timegm(expires) - date
freshness_lifetime = max(0, expire_time)
logger.debug("Freshness lifetime from expires: %i", freshness_lifetime)
# Determine if we are setting freshness limit in the
# request. Note, this overrides what was in the response.
if "max-age" in cc:
freshness_lifetime = cc["max-age"]
logger.debug(
"Freshness lifetime from request max-age: %i", freshness_lifetime
)
if "min-fresh" in cc:
min_fresh = cc["min-fresh"]
# adjust our current age by our min fresh
current_age += min_fresh
logger.debug("Adjusted current age from min-fresh: %i", current_age)
# Return entry if it is fresh enough
if freshness_lifetime > current_age:
logger.debug('The response is "fresh", returning cached response')
logger.debug("%i > %i", freshness_lifetime, current_age)
return resp
# we're not fresh. If we don't have an Etag, clear it out
if "etag" not in headers:
logger.debug('The cached response is "stale" with no etag, purging')
self.cache.delete(cache_url)
# return the original handler
return False
def conditional_headers(self, request):
cache_url = self.cache_url(request.url)
resp = self.serializer.loads(request, self.cache.get(cache_url))
new_headers = {}
if resp:
headers = CaseInsensitiveDict(resp.headers)
if "etag" in headers:
new_headers["If-None-Match"] = headers["ETag"]
if "last-modified" in headers:
new_headers["If-Modified-Since"] = headers["Last-Modified"]
return new_headers
def cache_response(self, request, response, body=None, status_codes=None):
"""
Algorithm for caching requests.
This assumes a requests Response object.
"""
# From httplib2: Don't cache 206's since we aren't going to
# handle byte range requests
cacheable_status_codes = status_codes or self.cacheable_status_codes
if response.status not in cacheable_status_codes:
logger.debug(
"Status code %s not in %s", response.status, cacheable_status_codes
)
return
response_headers = CaseInsensitiveDict(response.headers)
# If we've been given a body, our response has a Content-Length, that
# Content-Length is valid then we can check to see if the body we've
# been given matches the expected size, and if it doesn't we'll just
# skip trying to cache it.
if (
body is not None
and "content-length" in response_headers
and response_headers["content-length"].isdigit()
and int(response_headers["content-length"]) != len(body)
):
return
cc_req = self.parse_cache_control(request.headers)
cc = self.parse_cache_control(response_headers)
cache_url = self.cache_url(request.url)
logger.debug('Updating cache with response from "%s"', cache_url)
# Delete it from the cache if we happen to have it stored there
no_store = False
if "no-store" in cc:
no_store = True
logger.debug('Response header has "no-store"')
if "no-store" in cc_req:
no_store = True
logger.debug('Request header has "no-store"')
if no_store and self.cache.get(cache_url):
logger.debug('Purging existing cache entry to honor "no-store"')
self.cache.delete(cache_url)
if no_store:
return
# https://tools.ietf.org/html/rfc7234#section-4.1:
# A Vary header field-value of "*" always fails to match.
# Storing such a response leads to a deserialization warning
# during cache lookup and is not allowed to ever be served,
# so storing it can be avoided.
if "*" in response_headers.get("vary", ""):
logger.debug('Response header has "Vary: *"')
return
# If we've been given an etag, then keep the response
if self.cache_etags and "etag" in response_headers:
logger.debug("Caching due to etag")
self.cache.set(
cache_url, self.serializer.dumps(request, response, body=body)
)
# Add to the cache any 301s. We do this before looking that
# the Date headers.
elif response.status == 301:
logger.debug("Caching permanant redirect")
self.cache.set(cache_url, self.serializer.dumps(request, response))
# Add to the cache if the response headers demand it. If there
# is no date header then we can't do anything about expiring
# the cache.
elif "date" in response_headers:
# cache when there is a max-age > 0
if "max-age" in cc and cc["max-age"] > 0:
logger.debug("Caching b/c date exists and max-age > 0")
self.cache.set(
cache_url, self.serializer.dumps(request, response, body=body)
)
# If the request can expire, it means we should cache it
# in the meantime.
elif "expires" in response_headers:
if response_headers["expires"]:
logger.debug("Caching b/c of expires header")
self.cache.set(
cache_url, self.serializer.dumps(request, response, body=body)
)
def update_cached_response(self, request, response):
"""On a 304 we will get a new set of headers that we want to
update our cached value with, assuming we have one.
This should only ever be called when we've sent an ETag and
gotten a 304 as the response.
"""
cache_url = self.cache_url(request.url)
cached_response = self.serializer.loads(request, self.cache.get(cache_url))
if not cached_response:
# we didn't have a cached response
return response
# Lets update our headers with the headers from the new request:
# http://tools.ietf.org/html/draft-ietf-httpbis-p4-conditional-26#section-4.1
#
# The server isn't supposed to send headers that would make
# the cached body invalid. But... just in case, we'll be sure
# to strip out ones we know that might be problmatic due to
# typical assumptions.
excluded_headers = ["content-length"]
cached_response.headers.update(
dict(
(k, v)
for k, v in response.headers.items()
if k.lower() not in excluded_headers
)
)
# we want a 200 b/c we have content via the cache
cached_response.status = 200
# update our cache
self.cache.set(cache_url, self.serializer.dumps(request, cached_response))
return cached_response
PK ! A $ __pycache__/__init__.cpython-311.pycnu [
^i. : d Z dZdZdZddlmZ ddlmZ ddlm Z dS ) zbCacheControl import Interface.
Make it easy to import from cachecontrol without long namespaces.
z Eric Larsonzeric@ionrock.orgz0.12.6 ) CacheControl)CacheControlAdapter)CacheControllerN)
__doc__
__author__ __email__ __version__wrapperr adapterr
controllerr /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/__init__.pyr s\
! ! ! ! ! ! ( ( ( ( ( ( ' ' ' ' ' ' ' 'r PK ! v9 9 & __pycache__/controller.cpython-311.pycnu [
^iE7 d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m
Z
ddl m Z ej
e Z ej d Zd Z G d
d e ZdS ) z7
The httplib2 algorithms ported for use with requests.
N) parsedate_tz)CaseInsensitiveDict ) DictCache)
Serializerz9^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?c t | }|d |d |d |d |d fS )zParses a URI using the regex given in Appendix B of RFC 3986.
(scheme, authority, path, query, fragment) = parse_uri(uri)
r )URImatchgroups)urir s /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/controller.py parse_urir sD
YYs^^
"
"
$
$F 1Ivay&)VAYq BB c h e Zd ZdZ d dZed Zed Zd Zd Z d Z
d
d
Z d Z dS )CacheControllerz9An interface to see if request should cached or not.
NTc ~ |t n|| _ || _ |p
t | _ |pd| _ d S )N) i, - )r cache cache_etagsr
serializercacheable_status_codes)selfr r r status_codess r __init__zCacheController.__init__" sC %*MY[[[u
&$4
&2&J6J###r c t | \ }}}}}|r|st d|z | }| }|sd}|rd ||g p|}|dz |z |z }|S )z4Normalize the URL to create a safe key for the cachez(Only absolute URIs are allowed. uri = %s/?z://)r Exceptionlowerjoin) clsr scheme authoritypathqueryfragment request_uri
defrag_uris r _urlnormzCacheController._urlnorm* s 6?s^^2D% NY N F LMM M OO%% D 7$ 7 7?4 e^i/+=
r c , | | S N)r/ )r' r s r cache_urlzCacheController.cache_url> s ||C r c
t dft dft dfddddddddt dfd }| d| dd }i }| d D ]
}| s| d d
}|d } || \ }} n+# t $ r t
d | Y |w xY w|r| sd ||< |r ||d
||< # t $ r | rt
d
| Y t $ r% t
d||j Y w xY w|S )NTF)NF) max-agez max-stale min-freshno-cacheno-storez no-transformzonly-if-cachedzmust-revalidatepublicprivatezproxy-revalidatezs-maxagez
cache-controlz
Cache-Control ,=r r z,Ignoring unknown cache-control directive: %sz-Missing value for cache-control directive: %sz8Invalid value for cache-control directive %s, must be %s)
intgetsplitstripKeyErrorloggerdebug
IndexError
ValueError__name__)
r headersknown_directives
cc_headersretval cc_directiveparts directivetyprequireds
r parse_cache_controlz#CacheController.parse_cache_controlB s T{ u t%% ) + ,#$ - d
[[ '++or2R2RSS
& , ,S 1 1 L %%''
&&sA..E a((I
0 ;
XX
KYWWW
)h
)$(y!
(+E!HNN,<,<(=(=F9%%! N % " LLU!
s* 6 C%C*)C*9&D 'E7 *E76E7c | |j }t d| | |j }d|v r t d dS d|v r(|d dk r t d dS | j | }| t d dS | j || }|s t
d
dS |j d k r d }t | |S t |j }|rd
|vrTd|vr4t d | j
| t d dS t j }t j t# |d
} t% d|| z
}
t d|
| | } d} d| v r$| d } t d| n]d|v rYt# |d }
|
Bt j |
| z
}t% d| } t d| d|v r#|d } t d| d|v r(|d }|
|z
}
t d|
| |
k r8t d t d| |
|S d|vr4t d | j
| dS )ze
Return a cached response if it exists in the cache, otherwise
return False.
z Looking up "%s" in the cacher6 z-Request header has "no-cache", cache bypassedFr4 r z1Request header has "max_age" as 0, cache bypassedNzNo cache entry availablez1Cache entry deserialization failed, entry ignoredr zVReturning cached "301 Moved Permanently" response (ignoring date and etag information)dateetagz(Purging cached response: no date or etagz!Ignoring cached response: no datez Current age based on date: %iz#Freshness lifetime from max-age: %iexpiresz#Freshness lifetime from expires: %iz+Freshness lifetime from request max-age: %ir5 z'Adjusted current age from min-fresh: %iz2The response is "fresh", returning cached responsez%i > %iz4The cached response is "stale" with no etag, purging)r2 urlrB rC rP rG r r> r loadswarningstatusr deletetimecalendartimegmr max)r requestr2 cc
cache_datarespmsgrG nowrR current_ageresp_ccfreshness_lifetimerT expire_time min_freshs r cached_requestz CacheController.cached_requestx s|
NN7;// 3Y???
%
%go
6
6 LLH I I I5 ??r)} 1 1 LLL M M M5 Z^^I..
LL3 4 4 45 $$Wj99 NNN O O O5 ;# 7
LL K%dl33 &//W$$ GHHH
!!),,, LL< = = =5ikk|GFO < <==!S4Z(( 4kBBB **733 !(!3 LL>@R S S S S '
!
!"79#566G" &og 6 6 = %(K%8%8" BDVWWW ??!#I LL=?Q
" ;I 9 $K LLBK P P P + + LLM N N N LL$6 D D DK LLO P P P J i ( ( ( ur c | |j }| j || j | }i }|r2t
|j }d|v r |d |d< d|v r |d |d< |S )NrS ETagz
If-None-Matchz
last-modifiedz
Last-ModifiedzIf-Modified-Since)r2 rU r rV r r> r rG )r r^ r2 ra new_headersrG s r conditional_headersz#CacheController.conditional_headers s NN7;// $$WdjnnY.G.GHH L)$,77G /6v O, '))3:?3K /0r c |p| j }|j |vr#t d|j | dS t |j }|Fd|v rB|d r(t |d t | k rdS | |j }| | }|
|j } t d| d}
d|v r d}
t d d|v r d}
t d |
rN| j
| r4t d
| j | |
rdS d |
d d
v r t d dS | j rVd|v rRt d | j | | j ||| dS |j dk rPt d | j | | j || dS d|v rd|v r^|d dk rRt d | j | | j ||| dS d|v r\|d rVt d | j | | j ||| dS dS dS dS )zc
Algorithm for caching requests.
This assumes a requests Response object.
zStatus code %s not in %sNcontent-lengthz&Updating cache with response from "%s"Fr7 Tz Response header has "no-store"z Request header has "no-store"z0Purging existing cache entry to honor "no-store"*varyr: z Response header has "Vary: *"rS zCaching due to etag)bodyr zCaching permanant redirectrR r4 r z'Caching b/c date exists and max-age > 0rT z Caching b/c of expires header)r rX rB rC r rG isdigitr= lenrP r2 rU r r> rY r setr dumps) r r^ responserr r r response_headerscc_reqr_ r2 no_stores r cache_responsez CacheController.cache_response s ".!L1L ?"8 8 8 LL*HO=S
F.x/?@@
$444 !12::<< 5$%56773t99DD F))'/::
%
%&6
7
7NN7;// =yIII H LL9 : : : H LL8 9 9 9 )
y11 ) LLK L L L J i ( ( ( F "&&vr22 2 2 LL8 9 9 9 F *: : : LL. / / / JNN4?00(0NN
_
#
# LL5 6 6 6 JNN9do&;&;GX&N&N O O O O O
'
'
'B2i=1#4#4 FGGG
t 4 4WhT 4 R R ...#I. LL!@AAAJNN!4?#8#8(QU#8#V#V (
' /. r c | |j }| j || j | }|s|S dg|j t fd|j D d|_
| j || j || |S )zOn a 304 we will get a new set of headers that we want to
update our cached value with, assuming we have one.
This should only ever be called when we've sent an ETag and
gotten a 304 as the response.
ro c 3 R K | ]!\ }}| v||fV "d S r1 )r% ).0kvexcluded_headerss r z9CacheController.update_cached_response..k sK Aq7799$444 A4444 r r )
r2 rU r rV r r> rG updatedictitemsrX ru rv )r r^ rw r2 cached_responser s @r update_cached_responsez&CacheController.update_cached_responseR s NN7;// /// 9R9RSS O -- && $ , 2 2 4 4
"%
y$/"7"7 "Q"QRRR r )NTNN)NN)
rF
__module__ __qualname____doc__r classmethodr/ r2 rP ri rm r{ r r r r r s KOK K K K [& ! ! [!4 4 4lm m m^ Y Y Y Yv& & & & & r r )r loggingrer[ rZ email.utilsr pip._vendor.requests.structuresr r r serializer getLoggerrF rB compiler
r objectr r r r r s $ $ $ $ $ $ ? ? ? ? ? ? ! ! ! ! ! !
8 $ $bjMNNC C CZ Z Z Z Z f Z Z Z Z Z r PK ! F " __pycache__/compat.cpython-311.pycnu [
^i d dl mZ n# e$ r d dlmZ Y nw xY w d dlZn# e$ r d dlZY nw xY w d dlmZ n# e$ r d dlmZ Y nw xY w d dl m
Z
n# e$ r d dl m
Z
Y nw xY w e Z
dS # e$ r eZ
Y dS w xY w) )urljoinN) HTTPResponse) is_fp_closed) urllib.parser ImportErrorurlparsecPicklepickle.pip._vendor.requests.packages.urllib3.responser pip._vendor.urllib3.response*pip._vendor.requests.packages.urllib3.utilr pip._vendor.urllib3.utilunicode text_type NameErrorstr /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/compat.pyr s\ !$$$$$$$ ! ! ! ! MMMMM :KKKKKKK : : :99999999:6GGGGGGG 6 6 6555555556III IIIIsK ,,7 AA A A A "A& &A10A1PK ! ɕ # __pycache__/wrapper.cpython-311.pycnu [
^i 4 d dl mZ d dlmZ ddZdS ) )CacheControlAdapter) DictCacheNTc |t n|}|pt } ||||||| }| d| | d| | S )N) cache_etags
serializer heuristiccontroller_classcacheable_methodszhttp://zhttps://)r r mount) sesscacher r r r
adapter_classr
adapters /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/wrapper.py CacheControlr sw !=IKKKeE!8%8Mm
)+
G JJy'"""JJz7### K )NTNNNNN)r r r
r r r r r s^ ( ( ( ( ( (
r PK !
( ( % __pycache__/serialize.cpython-311.pycnu [
^i z d dl Z d dlZd dlZd dlZd dlmZ d dlmZ ddlm Z m
Z
m Z d Z d Z
G d d e ZdS )
N)msgpack)CaseInsensitiveDict ) HTTPResponsepickle text_typec P t j | d S )Nascii)base64 b64decodeencode)bs /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/serialize.py_b64_decode_bytesr s AHHW - - . .. c F t | d S )Nutf8)r decode)ss r _b64_decode_strr s Q & &v . ..r c @ e Zd Zd
dZd Zd Zd Zd Zd Zd Z d Z
dS )
SerializerNc t |j }|/| d }t j | |_ d|t
d |j D |j |j t |j |j |j
di}i |d< d|v rx|d d }|D ]Z}t | }|j |d }|t | }||d |< [d d t% j |d
g S ) NF)decode_contentresponsec 3 X K | ]%\ }}t | t | fV &d S N)r .0kvs r z#Serializer.dumps..2 sH ! !59QYq\\9Q<<0! ! ! ! ! !r )bodyheadersstatusversionreasonstrictr vary, ,s cc=4T) use_bin_type)r r$ readioBytesIO_fpdictitemsr% r& r r' r( r splitstripgetjoinr dumps) selfrequestr r# response_headersdatavaried_headersheader header_values r r7 zSerializer.dumps sl .x/?@@ <===66D :d++HL
! !=E=M=S=S=U=U! ! ! $? $ ,$X_55#?#+#:
W
& & & -g 6 < . sO -
-
1 Q
!3!3 4-
-
-
-
-
-
r r$ r' c 3 ` K | ])\ }}t | |t | n|fV *d S r r^ r s r r" z'Serializer._loads_v2.. sX
1 Q
q} !3!3!3! L
r r) ) jsonrH zlib
decompressr rC errorr r1 r2 r rT rZ s r _loads_v2zSerializer._loads_v2 sA Z 5 5 < rq s
? ? ? ? ? ? 3 3 3 3 3 3 3 3 3 3/ / // / /h6 h6 h6 h6 h6 h6 h6 h6 h6 h6r PK ! 6oK K & __pycache__/heuristics.cpython-311.pycnu [
^i d dl Z d dlZd dlmZmZmZ d dlmZmZ dZddZ d Z
G d de Z G d d
e Z
G d d e Z G d
de ZdS ) N)
formatdate parsedate parsedate_tz)datetime timedeltaz%a, %d %b %Y %H:%M:%S GMTc 6 |pt j }|| z S N)r utcnow)deltadates /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/heuristics.py expire_afterr s $8?$$D %< c h t t j | S r )r calendartimegm timetuple)dts r
datetime_to_headerr s" hobllnn55 6 66r c e Zd Zd Zd Zd ZdS )
BaseHeuristicc dS )a!
Return a valid 1xx warning header value describing the cache
adjustments.
The response is provided too allow warnings like 113
http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
to explicitly say response is over 24 hours old.
z110 - "Response is Stale" selfresponses r
warningzBaseHeuristic.warning s
+*r c i S )zUpdate the response headers with any new headers.
NOTE: This SHOULD always include some Warning header to
signify that the response was cached by the client, not
by way of the provided headers.
r r s r
update_headersz BaseHeuristic.update_headers! s r c | | }|rM|j | | | }| |j d|i |S )NWarning)r headersupdater )r r updated_headerswarning_header_values r
applyzBaseHeuristic.apply* so --h77 K # #O 4 4 4#'<<#9#9 #/ ''4H(IJJJr N)__name__
__module__ __qualname__r r r& r r r
r r sA + + + r r c e Zd ZdZd ZdS ) OneDayCachezM
Cache the response by providing an expires 1 day in the
future.
c i }d|j vr_t |j d }t t d t |d d }t | |d< d|d< |S ) Nexpiresr )days )r public
cache-control)r" r r r r r )r r r" r r- s r
r zOneDayCache.update_headers< su H , , , X -f 566D"9!#4#4#48T"1"X;NOOOG!3G! , - c * |j }d|v ri S d|v r|d dk ri S |j | j vri S d|vsd|vri S t j t |d }t
|d }||i S t j }t d||z
}|t j | z
}t dt |dz d }||k ri S ||z } dt j
t t j | iS ) Nr- r2 r1 r z
last-modifiedr
iQ )
r" status cacheable_by_default_statusesr r r r timemaxminstrftimeTIME_FMTgmtime)
r respr" r
last_modifiednow current_ager freshness_lifetimer- s
r
r zLastModified.update_headersh s/ , I g % %'/*Bh*N*NI ;d @ @ @I O7$B$BI|GFO < <==!'/":;;
<=0Iikk!S4Z(( x}555 C
I$>$> ? ? , ,I++4=4;w3G3GHHIIr c d S r r )r rS s r
r zLastModified.warning s tr N)r' r( r) r3 rL r r r r r
r= r= X sQ
% % %! J J J< r r= r )r rM email.utilsr r r r r rQ r r objectr r+ r5 r= r r r
r[ s( ; ; ; ; ; ; ; ; ; ; ( ( ( ( ( ( ( ( &
7 7 7 F D - "! ! ! ! != ! ! !"/ / / / /= / / / / /r PK ! L
! __pycache__/cache.cpython-311.pycnu [
^i% N d Z ddlmZ G d de Z G d de ZdS )zb
The cache object API for implementing caches. The default is a thread
safe in-memory dictionary.
)Lockc & e Zd Zd Zd Zd Zd ZdS ) BaseCachec t NNotImplementedErrorselfkeys /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/cache.pygetz
BaseCache.get
!### c t r r r r values r
setz
BaseCache.set
r r c t r r r
s r
deletezBaseCache.delete r r c d S r )r s r
closezBaseCache.close s r N)__name__
__module__ __qualname__r r r r r r r
r r sP $ $ $$ $ $$ $ $
r r c ( e Zd ZddZd Zd Zd ZdS ) DictCacheNc > t | _ |pi | _ d S r )r lockdata)r init_dicts r
__init__zDictCache.__init__ s FF O r c 8 | j |d S r )r! r r
s r
r z
DictCache.get s y}}S$'''r c ~ | j 5 | j ||i d d d d S # 1 swxY w Y d S r )r r! updater s r
r z
DictCache.set s
Y + + I c5\ * * * + + + + + + + + + + + + + + + + + +s 266c | j 5 || j v r| j | d d d d S # 1 swxY w Y d S r )r r! popr
s r
r zDictCache.delete$ s
Y # #di
c""" # # # # # # # # # # # # # # # # # #s
$9= =r )r r r r# r r r r r r
r r sU $ $ $ $( ( (+ + +# # # # #r r N)__doc__ threadingr objectr r r r r
r, s
# # # # # # # # # #r PK ! 4BJ J # __pycache__/adapter.cpython-311.pycnu [
^i j d dl Z d dlZd dlZd dlmZ ddlmZ ddlmZ ddl m
Z
G d de Z dS ) N) HTTPAdapter )CacheController) DictCache)CallbackFileWrapperc X e Zd ZddhZ d
fd Zd fd Z d fd Z fd Z xZS )
CacheControlAdapterPUTDELETENTc t t | j |i | |t n|| _ || _ |pd| _ |pt } | | j || | _ d S )N)GET) cache_etags
serializer) superr __init__r cache heuristiccacheable_methodsr
controller) selfr r controller_classr r r argskwcontroller_factory __class__s /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/adapter.pyr z CacheControlAdapter.__init__ s 2!4((14>2>>>$)MY[[[u
"!2!>h - @ ,, JKJ
c l |p| j }|j |v r | j | }n# t j $ r d}Y nw xY w|r| ||d S |j | j | t t | j |fi |}|S )z
Send a request. Use the request information to see if it
exists in the cache and cache the response if we need to and can.
NT)
from_cache)
r methodr cached_requestzliberrorbuild_responseheadersupdateconditional_headersr r send)r requestr r cacheablecached_responserespr s r r( zCacheControlAdapter.send$ s
&?)? >Y & &
'"&/"@"@"I"I:
'
'
'"&
'
V**7OPT*UUU
O " "4?#F#Fw#O#O P P P4u($//4WCCCC s 0 AAFc >
|p| j }|s|j |v r| j r| j | }|j dk rN| j || }||urd}| d | |}n|j dk r | j || net |j t j
| j j || |_ |j r&|j
fd}t! j || |_ t% t& | || }|j | j v r@|j r9| j |j } | j | ||_ |S )z
Build a response by making a request or using the cache.
This will end up calling send and returning a potentially
cached response
i0 TF)decode_contenti- c h | j dk r| j d S d S )Nr )
chunk_left_fp_close)r super_update_chunk_lengths r _update_chunk_lengthz@CacheControlAdapter.build_response.._update_chunk_lengthn s? 11333 ?a// HOO - - - - - 0/r ) r r r applystatusr update_cached_responseread release_conncache_responser r1 functoolspartialchunkedr4 types
MethodTyper r r$ invalidating_methodsok cache_urlurlr deleter ) r r) responser r r* r+ r4 r, rB r3 r s @r r$ z"CacheControlAdapter.build_response9 s &?)? 2 gn 9 9 ~
: >//99 #%%
#'/"H"HX# # #(22!%J
U
333%%'''* C''..wAAAA 3 L % 6 #
080M-. . . . .
5:4D,h5 5H1 ($//>>wQQ >T 6 6 647 6 11'+>>I J i ( ( ( % r c | j t t | d S N)r closer r )r r s r rH zCacheControlAdapter.close s:
!4((..00000r )NTNNNNrG )FN) __name__
__module__ __qualname__r@ r r( r$ rH
__classcell__)r s @r r r s !8,
* , FJH H H H H HT1 1 1 1 1 1 1 1 1r r ) r> r; r" pip._vendor.requests.adaptersr r r r r filewrapperr r r r rP s 5 5 5 5 5 5 ' ' ' ' ' ' , , , , , ,y1 y1 y1 y1 y1+ y1 y1 y1 y1 y1r PK ! ֺ
__pycache__/_cmd.cpython-311.pycnu [
^i d dl Z d dlmZ d dlmZ d dlmZ d dlmZ d dl m
Z
d Z d Z d Z
d d
Zed k r e dS dS )
N)requests)CacheControlAdapter) DictCache)logger)ArgumentParserc t j t j t j } t j | d S N)r setLevelloggingDEBUG
StreamHandler
addHandler)handlers /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/_cmd.py
setup_loggingr s9
OGM"""#%%G
g c t t dd d } t j }| d| | d| | j |_ |S )NT) cache_etags
serializer heuristiczhttp://zhttps://)r r r Sessionmount
controllercache_controller)adaptersesss r get_sessionr sk ! $$ G DJJy'"""JJz7### # .D Kr c t t } | dd | S )NurlzThe URL to try and cache)help)r add_argument
parse_args)parsers r get_argsr$ s9
F
$>??? r c V t } t }| | j }t |j |j |j |j |j rt d d S t d d S )NzCached!z
Not cached :() r$ r getr r r cache_responserequestrawcached_requestprint)argsr resps r mainr. $ s ::D ==D 88DH D OOO (( tx@@@ ++DL99
i
o r __main__r )r pip._vendorr pip._vendor.cachecontrol.adapterr pip._vendor.cachecontrol.cacher #pip._vendor.cachecontrol.controllerr argparser r r r$ r. __name__ r r r7 s @ @ @ @ @ @ 4 4 4 4 4 4 6 6 6 6 6 6 # # # # # # ( zDFFFFF r PK !
' __pycache__/filewrapper.cpython-311.pycnu [
^i . d dl mZ G d de ZdS ) )BytesIOc 8 e Zd ZdZd Zd Zd Zd Zd dZd Z dS )
CallbackFileWrapperav
Small wrapper around a fp object which will tee everything read into a
buffer, and when that file is closed it will execute a callback with the
contents of that buffer.
All attributes are proxied to the underlying file object.
This class uses members with a double underscore (__) leading prefix so as
not to accidentally shadow an attribute.
c H t | _ || _ || _ d S N)r _CallbackFileWrapper__buf_CallbackFileWrapper__fp _CallbackFileWrapper__callback)selffpcallbacks /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/filewrapper.py__init__z CallbackFileWrapper.__init__ s YY
" c L | d }t || S )Nr )__getattribute__getattr)r namer s r __getattr__z CallbackFileWrapper.__getattr__ s(
"
"#=
>
>r4 r c ~ | j j d u S # t $ r Y nw xY w | j j S # t $ r Y nw xY wdS )NF)r r AttributeErrorclosedr s r __is_fp_closedz"CallbackFileWrapper.__is_fp_closed! sm 9<4' ' D 9# # D
us
-
::c z | j r,| | j d | _ d S r )r
r getvaluer s r _closezCallbackFileWrapper._close2 s9 ? 3 OODJ / / 1 1 2 2 2 r Nc | j | }| j | | r| |S r )r readr write"_CallbackFileWrapper__is_fp_closedr r amtdatas r r zCallbackFileWrapper.read= sQ y~~c""
KKMMM r c | j | }|dk r|dk r|S | j | | r| |S )N s
)r
_safe_readr r r! r r" s r r' z CallbackFileWrapper._safe_readE sk y##C(( !88 K
KKMMM r r )
__name__
__module__ __qualname____doc__r r r! r r r' r r r r s} # # #
!
!
! " r r N)ior objectr r, r r r/ sU L L L L L& L L L L Lr PK ! Jy _cmd.pynu [ import logging
from pip._vendor import requests
from pip._vendor.cachecontrol.adapter import CacheControlAdapter
from pip._vendor.cachecontrol.cache import DictCache
from pip._vendor.cachecontrol.controller import logger
from argparse import ArgumentParser
def setup_logging():
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler()
logger.addHandler(handler)
def get_session():
adapter = CacheControlAdapter(
DictCache(), cache_etags=True, serializer=None, heuristic=None
)
sess = requests.Session()
sess.mount("http://", adapter)
sess.mount("https://", adapter)
sess.cache_controller = adapter.controller
return sess
def get_args():
parser = ArgumentParser()
parser.add_argument("url", help="The URL to try and cache")
return parser.parse_args()
def main(args=None):
args = get_args()
sess = get_session()
# Make a request to get a response
resp = sess.get(args.url)
# Turn on logging
setup_logging()
# try setting the cache
sess.cache_controller.cache_response(resp.request, resp.raw)
# Now try to get it
if sess.cache_controller.cached_request(resp.request):
print("Cached!")
else:
print("Not cached :(")
if __name__ == "__main__":
main()
PK ! d compat.pynu [ try:
from urllib.parse import urljoin
except ImportError:
from urlparse import urljoin
try:
import cPickle as pickle
except ImportError:
import pickle
# Handle the case where the requests module has been patched to not have
# urllib3 bundled as part of its source.
try:
from pip._vendor.requests.packages.urllib3.response import HTTPResponse
except ImportError:
from pip._vendor.urllib3.response import HTTPResponse
try:
from pip._vendor.requests.packages.urllib3.util import is_fp_closed
except ImportError:
from pip._vendor.urllib3.util import is_fp_closed
# Replicate some six behaviour
try:
text_type = unicode
except NameError:
text_type = str
PK ! Gi
adapter.pynu [ import types
import functools
import zlib
from pip._vendor.requests.adapters import HTTPAdapter
from .controller import CacheController
from .cache import DictCache
from .filewrapper import CallbackFileWrapper
class CacheControlAdapter(HTTPAdapter):
invalidating_methods = {"PUT", "DELETE"}
def __init__(
self,
cache=None,
cache_etags=True,
controller_class=None,
serializer=None,
heuristic=None,
cacheable_methods=None,
*args,
**kw
):
super(CacheControlAdapter, self).__init__(*args, **kw)
self.cache = DictCache() if cache is None else cache
self.heuristic = heuristic
self.cacheable_methods = cacheable_methods or ("GET",)
controller_factory = controller_class or CacheController
self.controller = controller_factory(
self.cache, cache_etags=cache_etags, serializer=serializer
)
def send(self, request, cacheable_methods=None, **kw):
"""
Send a request. Use the request information to see if it
exists in the cache and cache the response if we need to and can.
"""
cacheable = cacheable_methods or self.cacheable_methods
if request.method in cacheable:
try:
cached_response = self.controller.cached_request(request)
except zlib.error:
cached_response = None
if cached_response:
return self.build_response(request, cached_response, from_cache=True)
# check for etags and add headers if appropriate
request.headers.update(self.controller.conditional_headers(request))
resp = super(CacheControlAdapter, self).send(request, **kw)
return resp
def build_response(
self, request, response, from_cache=False, cacheable_methods=None
):
"""
Build a response by making a request or using the cache.
This will end up calling send and returning a potentially
cached response
"""
cacheable = cacheable_methods or self.cacheable_methods
if not from_cache and request.method in cacheable:
# Check for any heuristics that might update headers
# before trying to cache.
if self.heuristic:
response = self.heuristic.apply(response)
# apply any expiration heuristics
if response.status == 304:
# We must have sent an ETag request. This could mean
# that we've been expired already or that we simply
# have an etag. In either case, we want to try and
# update the cache if that is the case.
cached_response = self.controller.update_cached_response(
request, response
)
if cached_response is not response:
from_cache = True
# We are done with the server response, read a
# possible response body (compliant servers will
# not return one, but we cannot be 100% sure) and
# release the connection back to the pool.
response.read(decode_content=False)
response.release_conn()
response = cached_response
# We always cache the 301 responses
elif response.status == 301:
self.controller.cache_response(request, response)
else:
# Wrap the response file with a wrapper that will cache the
# response when the stream has been consumed.
response._fp = CallbackFileWrapper(
response._fp,
functools.partial(
self.controller.cache_response, request, response
),
)
if response.chunked:
super_update_chunk_length = response._update_chunk_length
def _update_chunk_length(self):
super_update_chunk_length()
if self.chunk_left == 0:
self._fp._close()
response._update_chunk_length = types.MethodType(
_update_chunk_length, response
)
resp = super(CacheControlAdapter, self).build_response(request, response)
# See if we should invalidate the cache.
if request.method in self.invalidating_methods and resp.ok:
cache_url = self.controller.cache_url(request.url)
self.cache.delete(cache_url)
# Give the request a from_cache attr to let people use it
resp.from_cache = from_cache
return resp
def close(self):
self.cache.close()
super(CacheControlAdapter, self).close()
PK ! %m^
heuristics.pynu [ import calendar
import time
from email.utils import formatdate, parsedate, parsedate_tz
from datetime import datetime, timedelta
TIME_FMT = "%a, %d %b %Y %H:%M:%S GMT"
def expire_after(delta, date=None):
date = date or datetime.utcnow()
return date + delta
def datetime_to_header(dt):
return formatdate(calendar.timegm(dt.timetuple()))
class BaseHeuristic(object):
def warning(self, response):
"""
Return a valid 1xx warning header value describing the cache
adjustments.
The response is provided too allow warnings like 113
http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
to explicitly say response is over 24 hours old.
"""
return '110 - "Response is Stale"'
def update_headers(self, response):
"""Update the response headers with any new headers.
NOTE: This SHOULD always include some Warning header to
signify that the response was cached by the client, not
by way of the provided headers.
"""
return {}
def apply(self, response):
updated_headers = self.update_headers(response)
if updated_headers:
response.headers.update(updated_headers)
warning_header_value = self.warning(response)
if warning_header_value is not None:
response.headers.update({"Warning": warning_header_value})
return response
class OneDayCache(BaseHeuristic):
"""
Cache the response by providing an expires 1 day in the
future.
"""
def update_headers(self, response):
headers = {}
if "expires" not in response.headers:
date = parsedate(response.headers["date"])
expires = expire_after(timedelta(days=1), date=datetime(*date[:6]))
headers["expires"] = datetime_to_header(expires)
headers["cache-control"] = "public"
return headers
class ExpiresAfter(BaseHeuristic):
"""
Cache **all** requests for a defined time period.
"""
def __init__(self, **kw):
self.delta = timedelta(**kw)
def update_headers(self, response):
expires = expire_after(self.delta)
return {"expires": datetime_to_header(expires), "cache-control": "public"}
def warning(self, response):
tmpl = "110 - Automatically cached for %s. Response might be stale"
return tmpl % self.delta
class LastModified(BaseHeuristic):
"""
If there is no Expires header already, fall back on Last-Modified
using the heuristic from
http://tools.ietf.org/html/rfc7234#section-4.2.2
to calculate a reasonable value.
Firefox also does something like this per
https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
Unlike mozilla we limit this to 24-hr.
"""
cacheable_by_default_statuses = {
200, 203, 204, 206, 300, 301, 404, 405, 410, 414, 501
}
def update_headers(self, resp):
headers = resp.headers
if "expires" in headers:
return {}
if "cache-control" in headers and headers["cache-control"] != "public":
return {}
if resp.status not in self.cacheable_by_default_statuses:
return {}
if "date" not in headers or "last-modified" not in headers:
return {}
date = calendar.timegm(parsedate_tz(headers["date"]))
last_modified = parsedate(headers["last-modified"])
if date is None or last_modified is None:
return {}
now = time.time()
current_age = max(0, now - date)
delta = date - calendar.timegm(last_modified)
freshness_lifetime = max(0, min(delta / 10, 24 * 3600))
if freshness_lifetime <= current_age:
return {}
expires = date + freshness_lifetime
return {"expires": time.strftime(TIME_FMT, time.gmtime(expires))}
def warning(self, resp):
return None
PK ! ߫ + caches/__pycache__/__init__.cpython-311.pycnu [
^iV d dl mZ d dlmZ dS ) ) FileCache)
RedisCacheN)
file_cacher redis_cacher /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/caches/__init__.pyr
s/ ! ! ! ! ! ! # # # # # # # #r PK ! 2cU U . caches/__pycache__/redis_cache.cpython-311.pycnu [
^iX F d dl mZ d dlmZ d dlmZ G d de ZdS ) )division)datetime) BaseCachec 4 e Zd Zd Zd ZddZd Zd Zd ZdS )
RedisCachec || _ d S N)conn)selfr
s /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py__init__zRedisCache.__init__ s
c 6 | j | S r )r
getr keys r r zRedisCache.get s y}}S!!!r Nc |s | j || d S |t j z
}| j |t | | d S r )r
setr utcnowsetexint
total_seconds)r r valueexpiress r r zRedisCache.set sk F IMM#u % % % % % 1 11G IOOCW%:%:%<%>## " "C I S ! ! ! ! " "r c dS )z?Redis uses connection pooling, no need to close the connection.N )r s r closezRedisCache.close s r r ) __name__
__module__ __qualname__r
r r r r r" r! r r r r sw " " "F F F F " " "
r r N)
__future__r r pip._vendor.cachecontrol.cacher r r! r r r( so 4 4 4 4 4 4
r PK ! ^ - caches/__pycache__/file_cache.cpython-311.pycnu [
^i9 d dl Z d dlZd dlmZ ddlmZ ddlmZ e n# e $ r e
e fZY nw xY wd Z G d de Z
d ZdS )
N)dedent ) BaseCache)CacheControllerc t j }|t j t j z z }t t d r|t j z }t t d r|t j z } t j | n# t t f$ r Y nw xY wt j
| || } t j |d S # t j | xY w)N
O_NOFOLLOWO_BINARYwb)
osO_WRONLYO_CREATO_EXCLhasattrr r removeIOErrorOSErroropenfdopenclose)filenamefmodeflagsfds /builddir/build/BUILDROOT/alt-python311-pip-21.3.1-4.el8.x86_64/opt/alt/python311/lib/python3.11/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py_secure_open_writer s KE
RZ")
##E r<
r:
( W
5% ( (ByT"""
s 2B BB5C
C!c N e Zd Z d dZed Zd Zd Zd Zd
Z dS ) FileCacheF Nc ||t d ddlm} ddlm} |r|}n1||}n,# t
$ r t
d } t | w xY w|| _ || _ || _ || _
|| _ d S )Nz/Cannot use use_dir_lock and lock_class togetherr )LockFile)
MkdirLockFilez
NOTE: In order to use the FileCache you must have
lockfile installed. You can install it via pip:
pip install lockfile
)
ValueErrorlockfiler! lockfile.mkdirlockfiler" ImportErrorr directoryforeverfilemodedirmode
lock_class)
selfr' r( r) r* use_dir_lockr+ r! r" notices
r __init__zFileCache.__init__: s #
(> NOO O & ) ) ) ) ) ) < < < < < <
& *
# %
& & & F f%% % &" #
$s + )Ac r t j | S N)hashlibsha224encode hexdigest)xs r r4 zFileCache.encodea s& ~ahhjj))33555 c | | }t |d d |gz }t j j | j g|R S )N )r4 listr pathjoinr' )r, namehashedpartss r _fnz
FileCache._fne sM T""VBQBZ F8+w|DN3U3333r7 c | | } t |d 5 }| cd d d S # 1 swxY w Y d S # t $ r Y d S w xY w)Nrb)r@ r readFileNotFoundError)r, keyr= fhs r getz
FileCache.getl s xx}} dD!!
!Rwwyy
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
!
! ! 44 s3 A A A A A A A
A#"A#c | | } t j t j | | j n# t t f$ r Y nw xY w| | 5 }t |j | j
5 }| | d d d n # 1 swxY w Y d d d d S # 1 swxY w Y d S r1 ) r@ r makedirsr; dirnamer* r r r+ r r) write)r, rE valuer= lockrF s r setz
FileCache.setu sJ xx}} K--t| < < < <! D __T
"
" d#DIt}==
sG 7A A#"A#;CB8, C8B< <C?B< CCCc | | }| j s( t j | d S # t $ r Y d S w xY wd S r1 )r@ r( r r rD )r, rE r= s r deletezFileCache.delete s] xx}}|
$$
s 4
AA)Fr r NN)
__name__
__module__ __qualname__r/ staticmethodr4 r@ rG rN rP r7 r r r 8 s
%% %% %% %%N 6 6 \64 4 4 r7 r c T t j | }| | S )z\Return the file cache path based on the URL.
This does not ensure the file exists!
)r cache_urlr@ )url filecacherE s r url_to_file_pathrZ s&
#C
(
(C == r7 )r2 r textwrapr cacher
controllerr rD NameErrorr r r r rZ rU r7 r r_ s ( ( ( ( ( (+ + + + '*+
& & &RQ Q Q Q Q Q Q Qh s ++PK ! AX X caches/redis_cache.pynu [ from __future__ import division
from datetime import datetime
from pip._vendor.cachecontrol.cache import BaseCache
class RedisCache(BaseCache):
def __init__(self, conn):
self.conn = conn
def get(self, key):
return self.conn.get(key)
def set(self, key, value, expires=None):
if not expires:
self.conn.set(key, value)
else:
expires = expires - datetime.utcnow()
self.conn.setex(key, int(expires.total_seconds()), value)
def delete(self, key):
self.conn.delete(key)
def clear(self):
"""Helper for clearing all the keys in a database. Use with
caution!"""
for key in self.conn.keys():
self.conn.delete(key)
def close(self):
"""Redis uses connection pooling, no need to close the connection."""
pass
PK ! /9 9 caches/file_cache.pynu [ import hashlib
import os
from textwrap import dedent
from ..cache import BaseCache
from ..controller import CacheController
try:
FileNotFoundError
except NameError:
# py2.X
FileNotFoundError = (IOError, OSError)
def _secure_open_write(filename, fmode):
# We only want to write to this file, so open it in write only mode
flags = os.O_WRONLY
# os.O_CREAT | os.O_EXCL will fail if the file already exists, so we only
# will open *new* files.
# We specify this because we want to ensure that the mode we pass is the
# mode of the file.
flags |= os.O_CREAT | os.O_EXCL
# Do not follow symlinks to prevent someone from making a symlink that
# we follow and insecurely open a cache file.
if hasattr(os, "O_NOFOLLOW"):
flags |= os.O_NOFOLLOW
# On Windows we'll mark this file as binary
if hasattr(os, "O_BINARY"):
flags |= os.O_BINARY
# Before we open our file, we want to delete any existing file that is
# there
try:
os.remove(filename)
except (IOError, OSError):
# The file must not exist already, so we can just skip ahead to opening
pass
# Open our file, the use of os.O_CREAT | os.O_EXCL will ensure that if a
# race condition happens between the os.remove and this line, that an
# error will be raised. Because we utilize a lockfile this should only
# happen if someone is attempting to attack us.
fd = os.open(filename, flags, fmode)
try:
return os.fdopen(fd, "wb")
except:
# An error occurred wrapping our FD in a file object
os.close(fd)
raise
class FileCache(BaseCache):
def __init__(
self,
directory,
forever=False,
filemode=0o0600,
dirmode=0o0700,
use_dir_lock=None,
lock_class=None,
):
if use_dir_lock is not None and lock_class is not None:
raise ValueError("Cannot use use_dir_lock and lock_class together")
try:
from lockfile import LockFile
from lockfile.mkdirlockfile import MkdirLockFile
except ImportError:
notice = dedent(
"""
NOTE: In order to use the FileCache you must have
lockfile installed. You can install it via pip:
pip install lockfile
"""
)
raise ImportError(notice)
else:
if use_dir_lock:
lock_class = MkdirLockFile
elif lock_class is None:
lock_class = LockFile
self.directory = directory
self.forever = forever
self.filemode = filemode
self.dirmode = dirmode
self.lock_class = lock_class
@staticmethod
def encode(x):
return hashlib.sha224(x.encode()).hexdigest()
def _fn(self, name):
# NOTE: This method should not change as some may depend on it.
# See: https://github.com/ionrock/cachecontrol/issues/63
hashed = self.encode(name)
parts = list(hashed[:5]) + [hashed]
return os.path.join(self.directory, *parts)
def get(self, key):
name = self._fn(key)
try:
with open(name, "rb") as fh:
return fh.read()
except FileNotFoundError:
return None
def set(self, key, value):
name = self._fn(key)
# Make sure the directory exists
try:
os.makedirs(os.path.dirname(name), self.dirmode)
except (IOError, OSError):
pass
with self.lock_class(name) as lock:
# Write our actual file
with _secure_open_write(lock.path, self.filemode) as fh:
fh.write(value)
def delete(self, key):
name = self._fn(key)
if not self.forever:
try:
os.remove(name)
except FileNotFoundError:
pass
def url_to_file_path(url, filecache):
"""Return the file cache path based on the URL.
This does not ensure the file exists!
"""
key = CacheController.cache_url(url)
return filecache._fn(key)
PK ! 0V V caches/__init__.pynu [ from .file_cache import FileCache # noqa
from .redis_cache import RedisCache # noqa
PK ! =Ҳ
wrapper.pynu [ from .adapter import CacheControlAdapter
from .cache import DictCache
def CacheControl(
sess,
cache=None,
cache_etags=True,
serializer=None,
heuristic=None,
controller_class=None,
adapter_class=None,
cacheable_methods=None,
):
cache = DictCache() if cache is None else cache
adapter_class = adapter_class or CacheControlAdapter
adapter = adapter_class(
cache,
cache_etags=cache_etags,
serializer=serializer,
heuristic=heuristic,
controller_class=controller_class,
cacheable_methods=cacheable_methods,
)
sess.mount("http://", adapter)
sess.mount("https://", adapter)
return sess
PK ! bM% % cache.pynu [ """
The cache object API for implementing caches. The default is a thread
safe in-memory dictionary.
"""
from threading import Lock
class BaseCache(object):
def get(self, key):
raise NotImplementedError()
def set(self, key, value):
raise NotImplementedError()
def delete(self, key):
raise NotImplementedError()
def close(self):
pass
class DictCache(BaseCache):
def __init__(self, init_dict=None):
self.lock = Lock()
self.data = init_dict or {}
def get(self, key):
return self.data.get(key, None)
def set(self, key, value):
with self.lock:
self.data.update({key: value})
def delete(self, key):
with self.lock:
if key in self.data:
self.data.pop(key)
PK ! Z. . __init__.pynu [ """CacheControl import Interface.
Make it easy to import from cachecontrol without long namespaces.
"""
__author__ = "Eric Larson"
__email__ = "eric@ionrock.org"
__version__ = "0.12.6"
from .wrapper import CacheControl
from .adapter import CacheControlAdapter
from .controller import CacheController
PK ! filewrapper.pynu [ from io import BytesIO
class CallbackFileWrapper(object):
"""
Small wrapper around a fp object which will tee everything read into a
buffer, and when that file is closed it will execute a callback with the
contents of that buffer.
All attributes are proxied to the underlying file object.
This class uses members with a double underscore (__) leading prefix so as
not to accidentally shadow an attribute.
"""
def __init__(self, fp, callback):
self.__buf = BytesIO()
self.__fp = fp
self.__callback = callback
def __getattr__(self, name):
# The vaguaries of garbage collection means that self.__fp is
# not always set. By using __getattribute__ and the private
# name[0] allows looking up the attribute value and raising an
# AttributeError when it doesn't exist. This stop thigns from
# infinitely recursing calls to getattr in the case where
# self.__fp hasn't been set.
#
# [0] https://docs.python.org/2/reference/expressions.html#atom-identifiers
fp = self.__getattribute__("_CallbackFileWrapper__fp")
return getattr(fp, name)
def __is_fp_closed(self):
try:
return self.__fp.fp is None
except AttributeError:
pass
try:
return self.__fp.closed
except AttributeError:
pass
# We just don't cache it then.
# TODO: Add some logging here...
return False
def _close(self):
if self.__callback:
self.__callback(self.__buf.getvalue())
# We assign this to None here, because otherwise we can get into
# really tricky problems where the CPython interpreter dead locks
# because the callback is holding a reference to something which
# has a __del__ method. Setting this to None breaks the cycle
# and allows the garbage collector to do it's thing normally.
self.__callback = None
def read(self, amt=None):
data = self.__fp.read(amt)
self.__buf.write(data)
if self.__is_fp_closed():
self._close()
return data
def _safe_read(self, amt):
data = self.__fp._safe_read(amt)
if amt == 2 and data == b"\r\n":
# urllib executes this read to toss the CRLF at the end
# of the chunk.
return data
self.__buf.write(data)
if self.__is_fp_closed():
self._close()
return data
PK ! 2`\ ' __pycache__/filewrapper.cpython-310.pycnu [ o
ai @ s d dl mZ G dd deZdS ) )BytesIOc @ sB e Zd ZdZdd Zdd Zdd Zdd Zdd d Zd
d Z d
S )CallbackFileWrapperav
Small wrapper around a fp object which will tee everything read into a
buffer, and when that file is closed it will execute a callback with the
contents of that buffer.
All attributes are proxied to the underlying file object.
This class uses members with a double underscore (__) leading prefix so as
not to accidentally shadow an attribute.
c C s t | _|| _|| _d S N)r _CallbackFileWrapper__buf_CallbackFileWrapper__fp _CallbackFileWrapper__callback)selffpcallback r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/filewrapper.py__init__ s
z CallbackFileWrapper.__init__c C s | d}t||S )Nr )__getattribute__getattr)r namer r r r __getattr__ s
z CallbackFileWrapper.__getattr__c C sB z| j jd u W S ty Y nw z| j jW S ty Y dS w )NF)r r AttributeErrorclosedr r r r __is_fp_closed! s
z"CallbackFileWrapper.__is_fp_closedc C s | j r | | j d | _ d S r )r r getvaluer r r r _close2 s
zCallbackFileWrapper._closeNc C s, | j |}| j| | r| |S r )r readr write"_CallbackFileWrapper__is_fp_closedr r amtdatar r r r = s
zCallbackFileWrapper.readc C s@ | j |}|dkr|dkr|S | j| | r | |S )N s
)r
_safe_readr r r r r r r r r E s z CallbackFileWrapper._safe_readr )
__name__
__module__ __qualname____doc__r
r r r r r r r r r r s
r N)ior objectr r r r r s PK ! IX X __pycache__/_cmd.cpython-310.pycnu [ o
ai @ s| d dl Z d dlmZ d dlmZ d dlmZ d dlmZ d dl m
Z
dd Z d d
Z d d Z
dd
dZedkr t t dd d d} t }|d| |d| | j|_|S )NT) cache_etags
serializer heuristiczhttp://zhttps://)r r r Sessionmount
controllercache_controller)adaptersessr r r get_session s
r c C s t } | jddd | S )NurlzThe URL to try and cache)help)r add_argument
parse_args)parserr r r get_args s r c C sV t } t }|| j}t |j|j|j |j |jr%t
d d S t
d d S )NzCached!z
Not cached :() r r getr r r cache_responserequestrawcached_requestprint)argsr respr r r main$ s r) __main__r )r pip._vendorr Z pip._vendor.cachecontrol.adapterr Z pip._vendor.cachecontrol.cacher Z#pip._vendor.cachecontrol.controllerr argparser r r r r) __name__r r r r s
PK ! -҃P P ! __pycache__/cache.cpython-310.pycnu [ o
ai% @ s4 d Z ddlmZ G dd deZG dd deZdS )zb
The cache object API for implementing caches. The default is a thread
safe in-memory dictionary.
)Lockc @ s, e Zd Zdd Zdd Zdd Zdd Zd S )
BaseCachec C t NNotImplementedErrorselfkey r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/cache.pyget
z
BaseCache.getc C r r r r r
valuer r r set
r z
BaseCache.setc C r r r r r r r delete r zBaseCache.deletec C s d S r r )r r r r close s zBaseCache.closeN)__name__
__module__ __qualname__r
r r r r r r r r s
r c @ s. e Zd Zd
ddZdd Zdd Zdd ZdS ) DictCacheNc C s t | _|pi | _d S r )r lockdata)r init_dictr r r __init__ s zDictCache.__init__c C s | j |d S r )r r
r r r r r
s z
DictCache.getc C s< | j | j||i W d d S 1 sw Y d S r )r r updater r r r r s "z
DictCache.setc C sR | j || jv r| j| W d d S W d d S 1 s"w Y d S r )r r popr r r r r $ s
"zDictCache.deleter )r r r r r
r r r r r r r s
r N)__doc__ threadingr objectr r r r r r s PK ! ~aQ Q $ __pycache__/__init__.cpython-310.pycnu [ o
ai. @ s8 d Z dZdZdZddlmZ ddlmZ ddlm Z dS ) zbCacheControl import Interface.
Make it easy to import from cachecontrol without long namespaces.
z Eric Larsonzeric@ionrock.orgz0.12.6 ) CacheControl)CacheControlAdapter)CacheControllerN)
__doc__
__author__ __email__ __version__wrapperr adapterr
controllerr r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/__init__.py s PK ! H0 " __pycache__/compat.cpython-310.pycnu [ o
ai @ s zd dl mZ W n ey d dlmZ Y nw zd dlZW n
ey+ d dlZY nw zd dlmZ W n eyC d dlmZ Y nw zd dl m
Z
W n ey[ d dl m
Z
Y nw ze Z
W dS eym eZ
Y dS w ) )urljoinN) HTTPResponse) is_fp_closed) urllib.parser ImportErrorurlparsecPicklepickleZ.pip._vendor.requests.packages.urllib3.responser Z pip._vendor.urllib3.responseZ*pip._vendor.requests.packages.urllib3.utilr pip._vendor.urllib3.utilunicode text_type NameErrorstr r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/compat.py s2
PK ! H& % __pycache__/serialize.cpython-310.pycnu [ o
ai @ sp d dl Z d dlZd dlZd dlZd dlmZ d dlmZ ddlm Z m
Z
m Z dd Z dd Z
G d
d d eZdS ) N)msgpack)CaseInsensitiveDict ) HTTPResponsepickle text_typec C s t | dS )Nascii)base64 b64decodeencode)b r
/builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/serialize.py_b64_decode_bytes s r c C s t | dS )Nutf8)r decode)sr
r
r _b64_decode_str s r c @ sN e Zd ZdddZdd Zdd Zdd Zd
d Zd d
Zdd Z dd Z
dS )
SerializerNc C s t |j}|d u r|jdd}t||_d|tdd |j D |j|j t
|j |j |j
di}i |d< d|v ra|d d}|D ] }t
| }|j|d }|d urZt
|}||d |< qCd d
tj|d d gS )
NF)decode_contentresponsec s $ | ]
\}}t |t |fV qd S N)r .0kvr
r
r 2 s
z#Serializer.dumps..)bodyheadersstatusversionreasonstrictr vary, ,s cc=4T) use_bin_type)r r readioBytesIO_fpdictitemsr r! r r" r# r splitstripgetjoinr dumps) selfrequestr r response_headersdatavaried_headersheader header_valuer
r
r r2 s4
zSerializer.dumpsc C s |sd S z
| dd\}}W n ty d}Y nw |d d dkr(|| }d}| ddd d}z t| d |||W S tyI Y d S w )
Nr& r s cc=0 s cc= =r z
_loads_v{})r.
ValueErrorr getattrformatAttributeError)r3 r4 r6 verr
r
r loadsJ s zSerializer.loadsc C s d| di v r
dS | di D ]\}}|j |d|kr" dS q|d d}t|d d d}| dd d
kr@|d ||d d< zt|}W n ty^ t|d }Y nw t d|d d
|d S )z`Verify our vary headers match and construct a real urllib3
HTTPResponse object.
*r$ Nr r r )r6 ztransfer-encoding chunkedr F)r preload_contentr
)
r0 r- r popr r) r* TypeErrorr r )r3 r4 cachedr8 valuebody_rawr r r
r
r prepare_responseh s"
zSerializer.prepare_responsec C d S r r
r3 r4 r6 r
r
r _loads_v0 zSerializer._loads_v0c C s0 zt |}W n
ty Y d S w | ||S r )r rB r= rL r3 r4 r6 rI r
r
r _loads_v1 s zSerializer._loads_v1c C s z
t t|d}W n
ttjfy Y d S w t|d d |d d< tdd |d d D |d d< t
|d d |d d< tdd |d D |d < | ||S )
Nr r r c s r r r r r
r
r r s
z'Serializer._loads_v2..r r" c s s0 | ]\}}t ||d urt |n|fV qd S r rS r r
r
r r s
r$ ) jsonrB zlib
decompressr r= errorr r, r- r rL rQ r
r
r _loads_v2 s
zSerializer._loads_v2c C rM r r
rN r
r
r _loads_v3 rP zSerializer._loads_v3c C s4 z t j|dd}W n
ty Y d S w | ||S )NF)raw)r rB r= rL rQ r
r
r _loads_v4 s zSerializer._loads_v4r ) __name__
__module__ __qualname__r2 rB rL rO rR rX rY r[ r
r
r
r r s
4 & r )r r) rT rU pip._vendorr Z pip._vendor.requests.structuresr compatr r r r r objectr r
r
r
r s PK ! / & __pycache__/heuristics.cpython-310.pycnu [ o
ai @ s d dl Z d dlZd dlmZmZmZ d dlmZmZ dZdddZ dd Z
G d d
d
e Z G d d d e Z
G d
d de ZG dd de ZdS ) N)
formatdate parsedate parsedate_tz)datetime timedeltaz%a, %d %b %Y %H:%M:%S GMTc C s |pt }|| S N)r utcnow)deltadate r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/heuristics.py expire_after s r
c C s t t| S r )r calendartimegm timetuple)dtr r r datetime_to_header s r c @ s$ e Zd Zdd Zdd Zdd ZdS )
BaseHeuristicc C s dS )a!
Return a valid 1xx warning header value describing the cache
adjustments.
The response is provided too allow warnings like 113
http://tools.ietf.org/html/rfc7234#section-5.5.4 where we need
to explicitly say response is over 24 hours old.
z110 - "Response is Stale"r selfresponser r r warning s zBaseHeuristic.warningc C s i S )zUpdate the response headers with any new headers.
NOTE: This SHOULD always include some Warning header to
signify that the response was cached by the client, not
by way of the provided headers.
r r r r r update_headers! s z BaseHeuristic.update_headersc C s@ | |}|r |j| | |}|d ur |jd|i |S )NWarning)r headersupdater )r r Zupdated_headersZwarning_header_valuer r r apply* s
zBaseHeuristic.applyN)__name__
__module__ __qualname__r r r r r r r r s r c @ s e Zd ZdZdd ZdS ) OneDayCachezM
Cache the response by providing an expires 1 day in the
future.
c C sR i }d|j vr't|j d }ttddt|d d d}t||d< d|d< |S ) Nexpiresr
)days )r
public
cache-control)r r r
r r r )r r r r
r! r r r r < s
zOneDayCache.update_headersN)r r r __doc__r r r r r r 6 s r c @ s( e Zd ZdZdd Zdd Zdd ZdS ) ExpiresAfterz;
Cache **all** requests for a defined time period.
c K s t di || _d S )Nr )r r )r kwr r r __init__L s zExpiresAfter.__init__c C s t | j}t|ddS )Nr% )r! r& )r
r r )r r r! r r r r O s
zExpiresAfter.update_headersc C s d}|| j S )Nz:110 - Automatically cached for %s. Response might be stale)r )r r tmplr r r r S s
zExpiresAfter.warningN)r r r r' r* r r r r r r r( G s
r( c @ s( e Zd ZdZh dZdd Zdd ZdS ) LastModifieda
If there is no Expires header already, fall back on Last-Modified
using the heuristic from
http://tools.ietf.org/html/rfc7234#section-4.2.2
to calculate a reasonable value.
Firefox also does something like this per
https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
http://lxr.mozilla.org/mozilla-release/source/netwerk/protocol/http/nsHttpResponseHead.cpp#397
Unlike mozilla we limit this to 24-hr.
> i, i- i i i i i c
C s |j }d|v r i S d|v r|d dkri S |j| jvr i S d|vs%d|vr'i S tt|d }t|d }|d u s>|d u r@i S t }td|| }|t| }tdt |d d}||krbi S || } dt
t t | iS ) Nr! r& r% r
z
last-modifiedr
iQ )
r status cacheable_by_default_statusesr r r r timemaxminstrftimeTIME_FMTgmtime)
r respr r
Z
last_modifiednow current_ager freshness_lifetimer! r r r r h s* zLastModified.update_headersc C s d S r r )r r: r r r r s zLastModified.warningN)r r r r' r3 r r r r r r r, X s
r, r )r r4 email.utilsr r r r r r8 r
r objectr r r( r, r r r r s
"PK ! UwE E # __pycache__/adapter.cpython-310.pycnu [ o
ai @ s\ d dl Z d dlZd dlZd dlmZ ddlmZ ddlmZ ddl m
Z
G dd deZ dS ) N) HTTPAdapter )CacheController) DictCache)CallbackFileWrapperc s\ e Zd ZddhZ d fdd Zd fdd Z d fd
d Z fd d
Z ZS )CacheControlAdapterPUTDELETENTc
sX t t| j|i | |d u rt n|| _|| _|pd| _|p t} | | j||d| _d S )N)GET) cache_etags
serializer) superr __init__r cache heuristiccacheable_methodsr
controller)
selfr r controller_classr r r argskwcontroller_factory __class__ /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/adapter.pyr s
z CacheControlAdapter.__init__c s |p| j }|j|v r3z| j|}W n tjy d}Y nw |r)| j||ddS |j| j | t
t | j |fi |}|S )z
Send a request. Use the request information to see if it
exists in the cache and cache the response if we need to and can.
NT)
from_cache)
r methodr cached_requestzliberrorbuild_responseheadersupdateconditional_headersr
r send)r requestr r cacheablecached_responserespr r r r% $ s
zCacheControlAdapter.sendFc
s |p| j }|sb|j|v rb| jr| j|}|jdkr4| j||}||ur'd}|jdd | |}n.|jdkrA| j || n!t
|j t
| jj |||_ |jrb|j fdd}t|||_tt| ||}|j| jv r|jr| j|j} | j| ||_|S )z
Build a response by making a request or using the cache.
This will end up calling send and returning a potentially
cached response
i0 TF)decode_contenti- c s" | j dkr| j d S d S )Nr )
chunk_left_fp_closer super_update_chunk_lengthr r _update_chunk_lengthn s
z@CacheControlAdapter.build_response.._update_chunk_length) r r r applystatusr update_cached_responseread release_conncache_responser r, functoolspartialchunkedr1 types
MethodTyper
r r! invalidating_methodsok cache_urlurlr deleter )
r r& responser r r' r( r1 r) r? r r/ r r! 9 sB
z"CacheControlAdapter.build_responsec s | j tt| d S N)r closer
r r. r r r rD s
zCacheControlAdapter.close)NTNNNNrC )FN) __name__
__module__ __qualname__r= r r% r! rD
__classcell__r r r r r s Jr ) r; r8 r Z pip._vendor.requests.adaptersr r r r r filewrapperr r r r r r s PK ! & # __pycache__/wrapper.cpython-310.pycnu [ o
ai @ s4 d dl mZ d dlmZ dddZdS ) )CacheControlAdapter) DictCacheNTc C sJ |d u rt n|}|p t}|||||||d}| d| | d| | S )N) cache_etags
serializer heuristiccontroller_classcacheable_methodszhttp://zhttps://)r r mount) sesscacher r r r
adapter_classr adapter r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/wrapper.py CacheControl s r )NTNNNNN)r
r r r r r r r r s PK ! NKD & __pycache__/controller.cpython-310.pycnu [ o
aiE7 @ s d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m
Z
ddl m Z e
eZedZd d
ZG d d d eZdS )
z7
The httplib2 algorithms ported for use with requests.
N) parsedate_tz)CaseInsensitiveDict ) DictCache)
Serializerz9^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?c C s0 t | }|d |d |d |d |d fS )zParses a URI using the regex given in Appendix B of RFC 3986.
(scheme, authority, path, query, fragment) = parse_uri(uri)
r )URImatchgroups)urir
r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/controller.py parse_uri s "r c @ s^ e Zd ZdZ dddZedd Zedd Zd
d Zd d
Z dd Z
dddZ dd Z dS )CacheControllerz9An interface to see if request should cached or not.
NTc C s4 |d u rt n|| _|| _|pt | _|pd| _d S )N) i, - )r cache cache_etagsr
serializercacheable_status_codes)selfr r r status_codesr r r __init__" s zCacheController.__init__c C sh t |\}}}}}|r
|std| | }| }|s d}|r(d||gp)|}|d | | }|S )z4Normalize the URL to create a safe key for the cachez(Only absolute URIs are allowed. uri = %s/?z://)r Exceptionlowerjoin) clsr scheme authoritypathqueryfragment request_uri
defrag_urir r r _urlnorm* s zCacheController._urlnormc C s
| |S N)r* )r" r r r r cache_url> s
zCacheController.cache_urlc
C s t dft dft dfddddddddt dfd }|d|dd}i }|dD ]c}| s/q(|d d
}|d }z|| \}} W n tyR td | Y q(w |rW| s[d ||< |rz ||d
||< W q( tyz | rxtd
| Y q( ty td||j Y q(w q(|S )NTF)NF) max-agez max-stale min-freshno-cacheno-storez no-transformzonly-if-cachedzmust-revalidatepublicprivatezproxy-revalidatezs-maxagez
cache-controlz
Cache-Control ,=r r z,Ignoring unknown cache-control directive: %sz-Missing value for cache-control directive: %sz8Invalid value for cache-control directive %s, must be %s)
intgetsplitstripKeyErrorloggerdebug
IndexError
ValueError__name__)
r headersknown_directives
cc_headersretval cc_directiveparts directivetyprequiredr r r parse_cache_controlB s^ z#CacheController.parse_cache_controlc C s& | |j}td| | |j}d|v r td dS d|v r.|d dkr.td dS | j|}|du r?td dS | j ||}|sOt
d
dS |j d kr]d }t| |S t |j}|rhd
|vr~d|vrwtd | j
| td dS t }tt|d
} td|| }
td|
| |} d} d| v r| d } td| n d|v rt|d }
|
durt|
| }td|} td| d|v r|d } td| d|v r|d }|
|7 }
td|
| |
krtd td| |
|S d|vrtd | j
| dS )ze
Return a cached response if it exists in the cache, otherwise
return False.
z Looking up "%s" in the cacher/ z-Request header has "no-cache", cache bypassedFr- r z1Request header has "max_age" as 0, cache bypassedNzNo cache entry availablez1Cache entry deserialization failed, entry ignoredr zVReturning cached "301 Moved Permanently" response (ignoring date and etag information)dateetagz(Purging cached response: no date or etagz!Ignoring cached response: no datez Current age based on date: %iz#Freshness lifetime from max-age: %iexpiresz#Freshness lifetime from expires: %iz+Freshness lifetime from request max-age: %ir. z'Adjusted current age from min-fresh: %iz2The response is "fresh", returning cached responsez%i > %iz4The cached response is "stale" with no etag, purging)r, urlr; r< rI r@ r r7 r loadswarningstatusr deletetimecalendartimegmr max)r requestr, cc
cache_datarespmsgr@ nowrJ current_ageresp_ccfreshness_lifetimerL expire_time min_freshr r r cached_requestx sz
z CacheController.cached_requestc C s` | |j}| j|| j|}i }|r.t|j}d|v r$|d |d< d|v r.|d |d< |S )NrK ETagz
If-None-Matchz
last-modifiedz
Last-ModifiedzIf-Modified-Since)r, rM r rN r r7 r r@ )r rV r, rY new_headersr@ r r r conditional_headers s
z#CacheController.conditional_headersc C s |p| j }|j|vrtd|j| dS t|j}|dur3d|v r3|d r3t|d t|kr3dS | |j}| |}|
|j } td| d}
d|v rWd}
td d|v rbd}
td |
ru| j
| rutd
| j | |
rydS d |
d d
v rtd dS | jrd|v rtd | j | | jj|||d dS |jdkrtd | j | | j|| dS d|v rd|v r|d dkrtd | j | | jj|||d dS d|v r|d rtd | j | | jj|||d dS dS dS dS )zc
Algorithm for caching requests.
This assumes a requests Response object.
zStatus code %s not in %sNcontent-lengthz&Updating cache with response from "%s"Fr0 Tz Response header has "no-store"z Request header has "no-store"z0Purging existing cache entry to honor "no-store"*varyr3 z Response header has "Vary: *"rK zCaching due to etag)bodyr zCaching permanant redirectrJ r- r z'Caching b/c date exists and max-age > 0rL z Caching b/c of expires header)r rP r; r< r r@ isdigitr6 lenrI r, rM r r7 rQ r setr dumps) r rV responserh r r response_headerscc_reqrW r, no_storer r r cache_response sn
z CacheController.cache_responsec sv | |j}| j|| j|}|s|S dg |jt fdd|j D d|_
| j || j || |S )zOn a 304 we will get a new set of headers that we want to
update our cached value with, assuming we have one.
This should only ever be called when we've sent an ETag and
gotten a 304 as the response.
re c 3 s( | ]\}}| vr||fV qd S r+ )r ).0kvexcluded_headersr r k s z9CacheController.update_cached_response..r )
r, rM r rN r r7 r@ updatedictitemsrP rk rl )r rV rm r, cached_responser ru r update_cached_responseR s z&CacheController.update_cached_response)NTNN)NN)
r?
__module__ __qualname____doc__r classmethodr* r, rI ra rd rq r| r r r r r s
6o
[r )r loggingrerS rR email.utilsr Z pip._vendor.requests.structuresr r r serializer getLoggerr? r; compiler r objectr r r r r s
PK ! BQ Q . caches/__pycache__/redis_cache.cpython-310.pycnu [ o
aiX @ s8 d dl mZ d dlmZ d dlmZ G dd deZdS ) )division)datetime) BaseCachec @ s> e Zd Zdd Zdd ZdddZdd Zd
d Zd d
ZdS )
RedisCachec C s
|| _ d S N)conn)selfr r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/redis_cache.py__init__ s
zRedisCache.__init__c C s | j |S r )r getr keyr r r
r s zRedisCache.getNc C s> |s | j || d S |t }| j |t| | d S r )r setr utcnowsetexint
total_seconds)r r valueexpiresr r r
r s zRedisCache.setc C s | j | d S r )r deleter
r r r
r s zRedisCache.deletec C s | j D ]}| j | qdS )zIHelper for clearing all the keys in a database. Use with
caution!N)r keysr r
r r r
clear s zRedisCache.clearc C s dS )z?Redis uses connection pooling, no need to close the connection.Nr )r r r r
close s zRedisCache.closer ) __name__
__module__ __qualname__r r r r r r r r r r
r s
r N)
__future__r r Z pip._vendor.cachecontrol.cacher r r r r r
s PK ! wYsC
C
- caches/__pycache__/file_cache.cpython-310.pycnu [ o
ai9 @ s| d dl Z d dlZd dlmZ ddlmZ ddlmZ ze W n
e y+ e
e fZY nw dd Z G dd d eZ
d
d ZdS ) N)dedent ) BaseCache)CacheControllerc C s t j}|t jt jB O }tt dr|t jO }tt dr |t jO }zt | W n tt fy1 Y nw t
| ||}zt |dW S t | )N
O_NOFOLLOWO_BINARYwb)
osO_WRONLYO_CREATO_EXCLhasattrr r removeIOErrorOSErroropenfdopenclose)filenamefmodeflagsfd r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/file_cache.py_secure_open_write s"
r c @ sL e Zd Z dddZedd Zd d
Zd d Zd
d Zdd Z dS ) FileCacheF Nc
C s |d ur |d ur t dzddlm} ddlm} W n ty) td} t| w |r/|}n|d u r5|}|| _|| _|| _ || _
|| _ d S )Nz/Cannot use use_dir_lock and lock_class togetherr )LockFile)
MkdirLockFilez
NOTE: In order to use the FileCache you must have
lockfile installed. You can install it via pip:
pip install lockfile
)
ValueErrorlockfiler lockfile.mkdirlockfiler ImportErrorr directoryforeverfilemodedirmode
lock_class)
selfr$ r% r& r' use_dir_lockr( r r noticer r r __init__: s(
zFileCache.__init__c C s t | S N)hashlibsha224encode hexdigest)xr r r r0 a s zFileCache.encodec C s6 | |}t|d d |g }tjj| jg|R S )N )r0 listr pathjoinr$ )r) namehashedpartsr r r _fne s
z
FileCache._fnc C sZ | |}z t|d
}| W d W S 1 sw Y W d S ty, Y d S w )Nrb)r: r readFileNotFoundError)r) keyr7 fhr r r getl s
( z
FileCache.getc C s | |}z
ttj|| j W n ttfy Y nw | |-}t |j| j
}| | W d n1 s;w Y W d d S W d d S 1 sSw Y d S r- ) r: r makedirsr5 dirnamer' r r r( r r& write)r) r> valuer7 lockr? r r r setu s
"z
FileCache.setc C s: | |}| jszt| W d S ty Y d S w d S r- )r: r% r r r= )r) r> r7 r r r delete s
zFileCache.delete)Fr r NN)
__name__
__module__ __qualname__r, staticmethodr0 r: r@ rF rG r r r r r 8 s
'
r c C s t | }||S )z\Return the file cache path based on the URL.
This does not ensure the file exists!
)r cache_urlr: )url filecacher> r r r url_to_file_path s
rO )r. r textwrapr cacher
controllerr r= NameErrorr r r r rO r r r r s ) TPK ! גoQ Q + caches/__pycache__/__init__.cpython-310.pycnu [ o
aiV @ s d dl mZ d dlmZ dS ) ) FileCache)
RedisCacheN)
file_cacher redis_cacher r r /builddir/build/BUILDROOT/alt-python310-pip-21.3.1-5.el8.x86_64/opt/alt/python310/lib/python3.10/site-packages/pip/_vendor/cachecontrol/caches/__init__.py s PK ! ȽZ serialize.pynu [ PK ! omE7 E7
controller.pynu [ PK ! A $ qS __pycache__/__init__.cpython-311.pycnu [ PK ! v9 9 & gV __pycache__/controller.cpython-311.pycnu [ PK ! F " f __pycache__/compat.cpython-311.pycnu [ PK ! ɕ # Z __pycache__/wrapper.cpython-311.pycnu [ PK !
( ( % __pycache__/serialize.cpython-311.pycnu [ PK ! 6oK K & __pycache__/heuristics.cpython-311.pycnu [ PK ! L
! __pycache__/cache.cpython-311.pycnu [ PK ! 4BJ J # __pycache__/adapter.cpython-311.pycnu [ PK ! ֺ
__pycache__/_cmd.cpython-311.pycnu [ PK !
' __pycache__/filewrapper.cpython-311.pycnu [ PK ! Jy
_cmd.pynu [ PK ! d E compat.pynu [ PK ! Gi
5 adapter.pynu [ PK ! %m^
) heuristics.pynu [ PK ! ߫ + 9 caches/__pycache__/__init__.cpython-311.pycnu [ PK ! 2cU U . ~; caches/__pycache__/redis_cache.cpython-311.pycnu [ PK ! ^ - 1E caches/__pycache__/file_cache.cpython-311.pycnu [ PK ! AX X d] caches/redis_cache.pynu [ PK ! /9 9 a caches/file_cache.pynu [ PK ! 0V V ~q caches/__init__.pynu [ PK ! =Ҳ
r wrapper.pynu [ PK ! bM% % u cache.pynu [ PK ! Z. . _x __init__.pynu [ PK ! y filewrapper.pynu [ PK ! 2`\ ' __pycache__/filewrapper.cpython-310.pycnu [ PK ! IX X __pycache__/_cmd.cpython-310.pycnu [ PK ! -҃P P ! __pycache__/cache.cpython-310.pycnu [ PK ! ~aQ Q $ 8 __pycache__/__init__.cpython-310.pycnu [ PK ! H0 " ݝ __pycache__/compat.cpython-310.pycnu [ PK ! H& % O __pycache__/serialize.cpython-310.pycnu [ PK ! / & O __pycache__/heuristics.cpython-310.pycnu [ PK ! UwE E # = __pycache__/adapter.cpython-310.pycnu [ PK ! & # __pycache__/wrapper.cpython-310.pycnu [ PK ! NKD & __pycache__/controller.cpython-310.pycnu [ PK ! BQ Q . caches/__pycache__/redis_cache.cpython-310.pycnu [ PK ! wYsC
C
- caches/__pycache__/file_cache.cpython-310.pycnu [ PK ! גoQ Q + / caches/__pycache__/__init__.cpython-310.pycnu [ PK ' ' <