File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/cachecontrol.tar
Back
__pycache__/wrapper.cpython-310.pyc 0000644 00000001213 15027746471 0013147 0 ustar 00 o �7]h � @ s4 d dl mZ d dlmZ ddd�ZdS )� )�CacheControlAdapter)� DictCacheNTc C sJ |d u rt � n|}|p t}|||||||d�}| �d|� | �d|� | S )N)� cache_etags� serializer� heuristic�controller_class�cacheable_methodszhttp://zhttps://)r r �mount) �sess�cacher r r r � adapter_classr �adapter� r �B/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/wrapper.py� CacheControl s � r )NTNNNNN)r r r r r r r r r �<module> s � __pycache__/compat.cpython-310.pyc 0000644 00000001320 15027746471 0012751 0 ustar 00 o �7]h � @ 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 � ImportError�urlparse�cPickle�pickle�.pip._vendor.requests.packages.urllib3.responser � pip._vendor.urllib3.response�*pip._vendor.requests.packages.urllib3.utilr �pip._vendor.urllib3.util�unicode� text_type� NameError�str� r r �A/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/compat.py�<module> s2 � � � � � __pycache__/__init__.cpython-310.pyc 0000644 00000001136 15027746471 0013232 0 ustar 00 o �7]h� � @ sT d Z dZdZdZddlmZ ddlmZ ddlm Z dd l Z e � e �� e �� � d S ) zbCacheControl import Interface. Make it easy to import from cachecontrol without long namespaces. z Eric Larsonzeric@ionrock.orgz0.12.10� )� CacheControl)�CacheControlAdapter)�CacheController� N)�__doc__� __author__� __email__� __version__�wrapperr �adapterr � controllerr �logging� getLogger�__name__� addHandler� NullHandler� r r �C/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/__init__.py�<module> s __pycache__/cache.cpython-310.pyc 0000644 00000003422 15027746471 0012536 0 ustar 00 o �7]h� � @ s4 d Z ddlmZ G dd� de�ZG dd� de�ZdS )zb The cache object API for implementing caches. The default is a thread safe in-memory dictionary. � )�Lockc @ s. e Zd Zdd� Zd dd�Zdd� Zdd � ZdS ) � BaseCachec C � t � ��N��NotImplementedError��self�key� r �@/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/cache.py�get � z BaseCache.getNc C r r r �r r �value�expiresr 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.closer )�__name__� __module__� __qualname__r r r r r r r r r s r c @ s0 e Zd Zd dd�Zdd� Zd dd�Zdd � ZdS ) � DictCacheNc C s t � | _|pi | _d S r )r �lock�data)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 �<module> s __pycache__/heuristics.cpython-310.pyc 0000644 00000011110 15027746471 0013646 0 ustar 00 o �7]h: � @ s� d dl Z d dlZd dlmZmZmZ d dlmZmZ dZddd�Z 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)�delta�date� r �E/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/heuristics.py� expire_after s r c C s t t�| �� ��S r )r �calendar�timegm� 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 ��self�responser r r �warning s zBaseHeuristic.warningc C s i S )z�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. r r r r r �update_headers% s z BaseHeuristic.update_headersc C s@ | � |�}|r |j�|� | �|�}|d ur |j�d|i� |S )N�Warning)r �headers�updater )r r �updated_headers�warning_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 �}ttdd�t|d d� � d�}t|�|d< d|d< |S ) N�expiresr � )�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" : 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__P s zExpiresAfter.__init__c C s t | j�}t|�dd�S )Nr' )r# r( )r r r )r r r# r r r r S 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 W s zExpiresAfter.warningN)r r r! r) r, r r r r r r r* K s r* c @ s( e Zd ZdZh d�Zdd� 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. > �, �- � � � � � �� �� �� �� 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 t�t|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 � i�Q ) r �status� cacheable_by_default_statusesr r r r �time�max�min�strftime�TIME_FMT�gmtime) r �respr r � last_modified�now� current_ager �freshness_lifetimer# r r r r l s* zLastModified.update_headersc C s d S r r )r rC r r r r � s zLastModified.warningN)r r r! r) r< r r r r r r r. \ s r. r )r r= � email.utilsr r r r r rA r r �objectr r" r* r. r r r r �<module> s " __pycache__/serialize.cpython-310.pyc 0000644 00000010167 15027746471 0013466 0 ustar 00 o �7]h � @ sv d dl Z d dlZd dlZd dlZd dlmZ d dlmZ ddlm Z m Z m Z dd� Z dd � Z e� ZG d d � d e�ZdS ) � N)�msgpack)�CaseInsensitiveDict� )� HTTPResponse�pickle� text_typec C s t �| �d��S )N�ascii)�base64� b64decode�encode)�b� r �D/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/serialize.py�_b64_decode_bytes s r c C s t | ��d�S )N�utf8)r �decode)�sr r r �_b64_decode_str s r c @ sN e Zd Zddd�Zdd� 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 d�i}i |d< d|v ra|d �d�}|D ] }t |��� }|j�|d �}|d urZt |�}||d |< qCd �d tj|d d �g�S ) NF)�decode_content�responsec s �$ � | ] \}}t |�t |�fV qd S �N)r ��.0�k�vr r r � <genexpr>0 s � �z#Serializer.dumps.<locals>.<genexpr>)�body�headers�status�version�reason�strictr �vary�,� ,s cc=4T)� use_bin_type)r r �read�io�BytesIO�_fp�dict�itemsr r! r r" r# r �split�strip�get�joinr �dumps) �self�requestr r �response_headers�data�varied_headers�header� header_valuer r r r2 s4 ��� zSerializer.dumpsc C s� |sd S z |� dd�\}}W n ty d}Y nw |d d� dkr(|| }d}|� dd�d �d�}z t| d �|��||�W S tyI Y d S w ) Nr& r s cc=0� s cc=� =���r z _loads_v{})r. � ValueErrorr �getattr�format�AttributeError)r3 r4 r6 �verr r r �loadsH 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 �value�body_rawr r r r r �prepare_responsef 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.<locals>.<genexpr>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 , & r )r r) rT rU � pip._vendorr � pip._vendor.requests.structuresr �compatr r r r r �object�_default_body_readr r r r r �<module> s __pycache__/controller.cpython-310.pyc 0000644 00000017756 15027746471 0013675 0 ustar 00 o �7]h = � @ s� d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl m Z ddl m Z e� e�Ze�d�Zd Zd d � ZG d d � d e�ZdS )z7 The httplib2 algorithms ported for use with requests. � N)� parsedate_tz)�CaseInsensitiveDict� )� DictCache)� Serializerz9^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)�- �4 c C s0 t �| ��� }|d |d |d |d |d fS )z�Parses a URI using the regex given in Appendix B of RFC 3986. (scheme, authority, path, query, fragment) = parse_uri(uri) r � � � � )�URI�match�groups)�urir � r �E/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/controller.py� parse_uri s "r c @ s^ e Zd ZdZ ddd�Zedd� �Zedd � �Zd d � Zd d � Z dd� Z ddd�Z 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 r )r �cache� cache_etagsr � serializer�cacheable_status_codes)�selfr r r � status_codesr r r �__init__( s zCacheController.__init__c C sh t |�\}}}}}|r |std| ��|�� }|�� }|s d}|r(d�||g�p)|}|d | | }|S )z4Normalize the URL to create a safe key for the cachez(Only absolute URIs are allowed. uri = %s�/�?z://)r � Exception�lower�join) �clsr �scheme� authority�path�query�fragment� request_uri� defrag_urir r r �_urlnorm0 s zCacheController._urlnormc C s | � |�S �N)r+ )r# r r r r � cache_urlD s zCacheController.cache_urlc C s t dft dft dfddddddddt dfd� }|�d|�dd��}i }|�d�D ]c}|�� s/q(|�d d �}|d �� }z|| \}} W n tyR t�d |� Y q(w |rW| s[d ||< |r�z ||d �� �||< W q( tyz | rxt�d |� Y q( ty� t�d||j � Y q(w q(|S )NTF)NF) �max-agez max-stale� min-fresh�no-cache�no-storez no-transformzonly-if-cachedzmust-revalidate�public�privatezproxy-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) �int�get�split�strip�KeyError�logger�debug� IndexError� ValueError�__name__) r �headers�known_directives� cc_headers�retval� cc_directive�parts� directive�typ�requiredr r r �parse_cache_controlH s^ � � �� ���z#CacheController.parse_cache_controlc C s* | � |j�}t�d|� | �|j�}d|v r t�d� dS d|v r.|d dkr.t�d� dS | j�|�}|du r?t�d � dS | j� ||�}|sOt� d � dS t |j �t v r_d }t�|� |S t|j�}|rjd |vr�d |vryt�d� | j�|� t�d� dS t�� }t�t|d ��} td|| �} t�d| � | �|�} d} d| v r�| d } t�d| � n d|v r�t|d �} | dur�t�| �| }td|�} t�d| � d|v r�|d } t�d| � d|v r�|d }| |7 } t�d| � | | k�rt�d� t�d| | � |S d |v�rt�d� | j�|� dS )ze Return a cached response if it exists in the cache, otherwise return False. z Looking up "%s" in the cacher0 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 ignoredzQReturning cached permanent redirect response (ignoring date and etag information)�date�etagz(Purging cached response: no date or etagz!Ignoring cached response: no datez Current age based on date: %iz#Freshness lifetime from max-age: %i�expiresz#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= rJ rA r r8 r �loads�warningr7 �status�PERMANENT_REDIRECT_STATUSESr �delete�time�calendar�timegmr �max)r �requestr- �cc� cache_data�resp�msgrA �nowrK � current_age�resp_cc�freshness_lifetimerM � expire_time� min_freshr r r �cached_request~ 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 )NrL �ETagz If-None-Matchz last-modifiedz Last-ModifiedzIf-Modified-Since)r- rN r rO r r8 r rA )r rX r- r[ � new_headersrA r r r �conditional_headers� s z#CacheController.conditional_headersc C s� |p| j }|j|vrt�d|j|� dS t|j�}d|v r't�t|d ��}nd}|durCd|v rC|d � � rCt |d �t |�krCdS | � |j�}| � |�} | � |j�} t�d| � d} d| v rgd } t�d � d|v rrd } t�d � | r�| j�| �r�t�d � | j�| � | r�dS d |�dd�v r�t�d� dS | jr�d|v r�d} |�d�r�t|d �} | dur�t�| �| } t| d�} t�d�| �� t�d� | jj| | j�|||�| d� dS t |j�tv r�t�d� | j�| | j�||d�� dS d|v �rbt�t|d ��}d| v �r)| d dk�r)t�d� | d } | jj| | j�|||�| d� dS d|v �rd|d �rft|d �} | du�rFt�| �| } nd} t�d�| �� | jj| | jj|||d �| d� dS dS dS dS ) zc Algorithm for caching requests. This assumes a requests Response object. zStatus code %s not in %sNrK r �content-lengthz&Updating cache with response from "%s"Fr1 Tz Response header has "no-store"z Request header has "no-store"z0Purging existing cache entry to honor "no-store"�*�varyr4 z Response header has "Vary: *"rL rM i u z"etag object cached for {0} secondszCaching due to etag)rM zCaching permanent redirect� r. z'Caching b/c date exists and max-age > 0z5Caching b/c of expires header. expires in {0} seconds)�body)r rQ r< r= r rA rU rV r �isdigitr7 �lenrJ r- rN r r8 rS r rW �format�setr �dumpsrR )r rX �responserk r r �response_headersrK �cc_reqrY r- �no_store� expires_timerM r r r �cache_response� s� � � � � �� ��z CacheController.cache_responsec sv | � |j�}| j�|| j�|��}|s|S dg� |j�t� fdd�|j� � D ��� d|_ | j� || j� ||�� |S )z�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. rg c 3 s( � | ]\}}|� � � vr||fV qd S r, )r! )�.0�k�v��excluded_headersr r � <genexpr>� s � ��z9CacheController.update_cached_response.<locals>.<genexpr>r ) r- rN r rO r r8 rA �update�dict�itemsrQ ro rp )r rX rq r- �cached_responser rz r �update_cached_responsey s �� z&CacheController.update_cached_response)NTNN)NN) r@ � __module__� __qualname__�__doc__r � classmethodr+ r- rJ rc rf rv r� r r r r r $ s � 6p {r )r� �logging�rerU rT � email.utilsr � pip._vendor.requests.structuresr r r � serializer � getLoggerr@ r< �compiler rR r �objectr r r r r �<module> s __pycache__/filewrapper.cpython-310.pyc 0000644 00000005304 15027746471 0014014 0 ustar 00 o �7]hj � @ s( d dl mZ d dlZG dd� de�ZdS )� )�NamedTemporaryFileNc @ sB e Zd ZdZdd� Zdd� Zdd� Zdd � Zdd d �Zd d� Z d S )�CallbackFileWrappera 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. The data is stored in a temporary file until it is all available. As long as the temporary files directory is disk-based (sometimes it's a memory-backed-``tmpfs`` on Linux), data will be unloaded to disk if memory pressure is high. For small files the disk usually won't be used at all, it'll all be in the filesystem memory cache, so there should be no performance impact. c C s t ddd�| _|| _|| _d S )Nzrb+T)�delete)r �_CallbackFileWrapper__buf�_CallbackFileWrapper__fp� _CallbackFileWrapper__callback)�self�fp�callback� r �F/usr/lib/python3/dist-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 �AttributeError�closed)r r r r �__is_fp_closed- s � �z"CallbackFileWrapper.__is_fp_closedc C sb | j r'| j�� dkr d}n| j�dd� ttj| j�� dtjd��}| � |� d | _ | j�� d S )Nr � )�access) r r �tell�seek� memoryview�mmap�fileno� ACCESS_READ�close)r �resultr r r �_close> s � zCallbackFileWrapper._closeNc C s0 | j �|�}|r| j�|� | �� r| �� |S �N)r �readr �write�"_CallbackFileWrapper__is_fp_closedr �r �amt�datar r r r! Y 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( d s z CallbackFileWrapper._safe_readr ) �__name__� __module__� __qualname__�__doc__r r r# r r! r( r r r r r s r )�tempfiler r �objectr r r r r �<module> s __pycache__/adapter.cpython-310.pyc 0000644 00000006060 15027746471 0013114 0 ustar 00 o �7]h� � @ s` d dl Z d dlZd dlZd dlmZ ddlmZmZ ddlm Z ddl m Z G dd� de�Z dS ) � N)� HTTPAdapter� )�CacheController�PERMANENT_REDIRECT_STATUSES)� DictCache)�CallbackFileWrapperc s\ e Zd Zh d�Z d � fdd� Zd� fdd� Z d� fd d � Z� fd d �Z� ZS )�CacheControlAdapter> �PUT�PATCH�DELETENTc 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� heuristic�cacheable_methodsr � controller) �selfr r �controller_classr r r �args�kw�controller_factory�� __class__� �B/usr/lib/python3/dist-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||dd�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_request�zlib�error�build_response�headers�update�conditional_headersr r �send)r �requestr r � cacheable�cached_response�respr r r r' ( s �zCacheControlAdapter.sendFc s |p| j }|sd|j|v rd| jr| j�|�}|jdkr4| j�||�}||ur'd}|jdd� |�� |}n0t |j�t v rC| j� ||� n!t |j t�| jj ||��|_ |jrd|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_contentc s" � � | j dkr| j�� d S d S )Nr )� chunk_left�_fp�_close�r ��super_update_chunk_lengthr r �_update_chunk_lengthr s �z@CacheControlAdapter.build_response.<locals>._update_chunk_length) r r r �apply�statusr �update_cached_response�read� release_conn�intr �cache_responser r. � functools�partial�chunkedr3 �types� MethodTyper r r# �invalidating_methods�ok� cache_url�urlr �deleter ) r r( �responser r r) r* r3 r+ rB r r1 r r# = sB � �� � z"CacheControlAdapter.build_responsec s | j �� tt| ��� d S �N)r �closer r r0 r r r rG � s zCacheControlAdapter.close)NTNNNNrF )FN) �__name__� __module__� __qualname__r@ r r' r# rG � __classcell__r r r r r s ��Jr ) r> r; r! � pip._vendor.requests.adaptersr r r r r r � filewrapperr r r r r r �<module> s __pycache__/_cmd.cpython-310.pyc 0000644 00000003010 15027746471 0012366 0 ustar 00 o �7]hc � @ 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 d�Zedkr<e� dS dS )� N)�requests)�CacheControlAdapter)� DictCache)�logger)�ArgumentParserc C s" t �tj� t�� } t �| � d S �N)r �setLevel�logging�DEBUG� StreamHandler� addHandler)�handler� r �?/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/_cmd.py� setup_logging s r c C s> t t� dd d d�} t�� }|�d| � |�d| � | j|_|S )NT)� cache_etags� serializer� heuristiczhttp://zhttps://)r r r �Session�mount� controller�cache_controller)�adapter�sessr r r � get_session s � r c C s t � } | jddd� | �� S )N�urlzThe 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� |j�r%t d� d S t d� d S )NzCached!z Not cached :() r r �getr r r �cache_response�request�raw�cached_request�print)�argsr �respr r r �main( s 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 r r �<module> s � heuristics.py 0000644 00000010072 15027746471 0007315 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 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 wrapper.py 0000644 00000001406 15027746471 0006614 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 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 cache.py 0000644 00000001625 15027746471 0006202 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 """ 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, expires=None): 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, expires=None): with self.lock: self.data.update({key: value}) def delete(self, key): with self.lock: if key in self.data: self.data.pop(key) filewrapper.py 0000644 00000007552 15027746471 0007464 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 from tempfile import NamedTemporaryFile import mmap 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. The data is stored in a temporary file until it is all available. As long as the temporary files directory is disk-based (sometimes it's a memory-backed-``tmpfs`` on Linux), data will be unloaded to disk if memory pressure is high. For small files the disk usually won't be used at all, it'll all be in the filesystem memory cache, so there should be no performance impact. """ def __init__(self, fp, callback): self.__buf = NamedTemporaryFile("rb+", delete=True) 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: if self.__buf.tell() == 0: # Empty file: result = b"" else: # Return the data without actually loading it into memory, # relying on Python's buffer API and mmap(). mmap() just gives # a view directly into the filesystem's memory cache, so it # doesn't result in duplicate memory use. self.__buf.seek(0, 0) result = memoryview( mmap.mmap(self.__buf.fileno(), 0, access=mmap.ACCESS_READ) ) self.__callback(result) # 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 # Closing the temporary file releases memory and frees disk space. # Important when caching big files. self.__buf.close() def read(self, amt=None): data = self.__fp.read(amt) if data: # We may be dealing with b'', a sign that things are over: # it's passed e.g. after we've already closed self.__buf. 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 _cmd.py 0000644 00000002543 15027746471 0006041 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 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() serialize.py 0000644 00000015177 15027746471 0007135 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 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") _default_body_read = object() class Serializer(object): def dumps(self, request, response, body=None): response_headers = CaseInsensitiveDict(response.headers) if body is None: # When a body isn't passed in, we'll read the response. We # also update the response with a new file handler to be # sure it acts as though it was never read. body = response.read(decode_content=False) 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) adapter.py 0000644 00000011651 15027746471 0006557 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 import types import functools import zlib from pip._vendor.requests.adapters import HTTPAdapter from .controller import CacheController, PERMANENT_REDIRECT_STATUSES from .cache import DictCache from .filewrapper import CallbackFileWrapper class CacheControlAdapter(HTTPAdapter): invalidating_methods = {"PUT", "PATCH", "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 int(response.status) in PERMANENT_REDIRECT_STATUSES: 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() controller.py 0000644 00000036411 15027746471 0007323 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 """ 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"^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?") PERMANENT_REDIRECT_STATUSES = (301, 308) 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, 308) @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 permanent redirect, 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 int(resp.status) in PERMANENT_REDIRECT_STATUSES: msg = ( "Returning cached permanent redirect 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 "date" in response_headers: date = calendar.timegm(parsedate_tz(response_headers["date"])) else: date = 0 # 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: expires_time = 0 if response_headers.get("expires"): expires = parsedate_tz(response_headers["expires"]) if expires is not None: expires_time = calendar.timegm(expires) - date expires_time = max(expires_time, 14 * 86400) logger.debug("etag object cached for {0} seconds".format(expires_time)) logger.debug("Caching due to etag") self.cache.set( cache_url, self.serializer.dumps(request, response, body), expires=expires_time, ) # Add to the cache any permanent redirects. We do this before looking # that the Date headers. elif int(response.status) in PERMANENT_REDIRECT_STATUSES: logger.debug("Caching permanent redirect") self.cache.set(cache_url, self.serializer.dumps(request, response, b"")) # 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: date = calendar.timegm(parsedate_tz(response_headers["date"])) # 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") expires_time = cc["max-age"] self.cache.set( cache_url, self.serializer.dumps(request, response, body), expires=expires_time, ) # If the request can expire, it means we should cache it # in the meantime. elif "expires" in response_headers: if response_headers["expires"]: expires = parsedate_tz(response_headers["expires"]) if expires is not None: expires_time = calendar.timegm(expires) - date else: expires_time = None logger.debug( "Caching b/c of expires header. expires in {0} seconds".format( expires_time ) ) self.cache.set( cache_url, self.serializer.dumps(request, response, body=body), expires=expires_time, ) 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 caches/__pycache__/__init__.cpython-310.pyc 0000644 00000000401 15027746471 0014452 0 ustar 00 o �7]h� � @ s d dl mZ d dlmZ dS )� )� FileCache)� RedisCacheN)� file_cacher � redis_cacher � r r �J/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/caches/__init__.py�<module> s caches/__pycache__/redis_cache.cpython-310.pyc 0000644 00000003001 15027746471 0015143 0 ustar 00 o �7]h� � @ s8 d dl mZ d dlmZ d dlmZ G dd� de�ZdS )� )�division)�datetime)� BaseCachec @ s> e Zd Zdd� Zdd� Zddd�Zdd � Zd d � Zd d � ZdS )� RedisCachec C s || _ d S �N)�conn)�selfr � r �M/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/caches/redis_cache.py�__init__ s zRedisCache.__init__c C s | j �|�S r )r �get�r �keyr r r r s zRedisCache.getNc C s> |s | j �||� d S |t�� }| j �|t|�� �|� d S r )r �setr �utcnow�setex�int� total_seconds)r r �value�expiresr 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 � pip._vendor.cachecontrol.cacher r r r r r �<module> s caches/__pycache__/file_cache.cpython-310.pyc 0000644 00000006403 15027746471 0014765 0 ustar 00 o �7]h� � @ s| d dl Z d dlZd dlmZ ddlmZ ddlmZ ze W n e y+ e e fZY nw dd� Z G dd � d e�Z d d � ZdS ) � N)�dedent� )� BaseCache)�CacheControllerc C s� t j}|t jt jB O }tt d�r|t jO }tt d�r |t jO }zt �| � W n tt fy1 Y nw t � | ||�}zt � |d�W S t � |� � )N� O_NOFOLLOW�O_BINARY�wb) �os�O_WRONLY�O_CREAT�O_EXCL�hasattrr r �remove�IOError�OSError�open�fdopen�close)�filename�fmode�flags�fd� r �L/usr/lib/python3/dist-packages/pip/_vendor/cachecontrol/caches/file_cache.py�_secure_open_write s" � r c @ sN e Zd Z ddd�Zedd� �Zd d � Zd d � Zdd d�Zdd� Z dS )� FileCacheF� � Nc C s� |d ur |d ur t d��zddlm} 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 ) � ValueError�lockfiler �lockfile.mkdirlockfiler � ImportErrorr � directory�forever�filemode�dirmode� lock_class) �selfr$ r% r& r' � use_dir_lockr( r r �noticer r r �__init__> s( �� zFileCache.__init__c C s t �| �� ��� S �N)�hashlib�sha224�encode� hexdigest)�xr r r r0 e s zFileCache.encodec C s6 | � |�}t|d d� �|g }tjj| jg|�R � S )N� )r0 �listr �path�joinr$ )r) �name�hashed�partsr r r �_fni s z FileCache._fnc C sZ | � |�}z t|d�� }|�� W d � W S 1 sw Y W d S ty, Y d S w )N�rb)r: r �read�FileNotFoundError)r) �keyr7 �fhr r r �getp s (� �z FileCache.getc C s� | � |�}z t�tj�|�| 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> �value�expiresr7 �lockr? r r r �sety 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 NNr- ) �__name__� __module__� __qualname__r, � staticmethodr0 r: r@ rG rH r r r r r < 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 rP )r. r �textwrapr �cacher � controllerr r= � NameErrorr r r r rP r r r r �<module> s �) T caches/redis_cache.py 0000644 00000001654 15027746471 0010620 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 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 caches/file_cache.py 0000644 00000010233 15027746471 0010422 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 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, expires=None): 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) caches/__init__.py 0000644 00000000252 15027746471 0010117 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 from .file_cache import FileCache # noqa from .redis_cache import RedisCache # noqa compat.py 0000644 00000001412 15027746471 0006414 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 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 __init__.py 0000644 00000000721 15027746471 0006672 0 ustar 00 # SPDX-FileCopyrightText: 2015 Eric Larson # # SPDX-License-Identifier: Apache-2.0 """CacheControl import Interface. Make it easy to import from cachecontrol without long namespaces. """ __author__ = "Eric Larson" __email__ = "eric@ionrock.org" __version__ = "0.12.10" from .wrapper import CacheControl from .adapter import CacheControlAdapter from .controller import CacheController import logging logging.getLogger(__name__).addHandler(logging.NullHandler())
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings