HEX

File: //usr/lib/python3/dist-packages/django/middleware/__pycache__/cache.cpython-310.pyc
o

3�a# �@s~dZddlmZddlmZmZddlmZmZm	Z	m
Z
mZddlm
Z
Gdd�de
�ZGdd	�d	e
�ZGd
d�dee�ZdS)
a�
Cache middleware. If enabled, each Django-powered page will be cached based on
URL. The canonical way to enable cache middleware is to set
``UpdateCacheMiddleware`` as your first piece of middleware, and
``FetchFromCacheMiddleware`` as the last::

    MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',
        ...
        'django.middleware.cache.FetchFromCacheMiddleware'
    ]

This is counter-intuitive, but correct: ``UpdateCacheMiddleware`` needs to run
last during the response phase, which processes middleware bottom-up;
``FetchFromCacheMiddleware`` needs to run last during the request phase, which
processes middleware top-down.

The single-class ``CacheMiddleware`` can be used for some simple sites.
However, if any other piece of middleware needs to affect the cache key, you'll
need to use the two-part ``UpdateCacheMiddleware`` and
``FetchFromCacheMiddleware``. This'll most often happen when you're using
Django's ``LocaleMiddleware``.

More details about how the caching works:

* Only GET or HEAD-requests with status code 200 are cached.

* The number of seconds each page is stored for is set by the "max-age" section
  of the response's "Cache-Control" header, falling back to the
  CACHE_MIDDLEWARE_SECONDS setting if the section was not found.

* This middleware expects that a HEAD request is answered with the same response
  headers exactly like the corresponding GET request.

* When a hit occurs, a shallow copy of the original response object is returned
  from process_request.

* Pages will be cached based on the contents of the request headers listed in
  the response's "Vary" header.

* This middleware also sets ETag, Last-Modified, Expires and Cache-Control
  headers on the response object.

�)�settings)�DEFAULT_CACHE_ALIAS�caches)�
get_cache_key�get_max_age�has_vary_header�learn_cache_key�patch_response_headers)�MiddlewareMixincs2eZdZdZd	�fdd�	Zdd�Zdd�Z�ZS)
�UpdateCacheMiddlewarea6
    Response-phase cache middleware that updates the cache if the response is
    cacheable.

    Must be used as part of the two-part update/fetch cache middleware.
    UpdateCacheMiddleware must be the first piece of middleware in MIDDLEWARE
    so that it'll get called last during the response phase.
    Ncs:t��|�tj|_d|_tj|_tj|_	t
|j	|_dS�N)�super�__init__r�CACHE_MIDDLEWARE_SECONDS�
cache_timeout�page_timeout�CACHE_MIDDLEWARE_KEY_PREFIX�
key_prefix�CACHE_MIDDLEWARE_ALIAS�cache_aliasr�cache��self�get_response��	__class__��9/usr/lib/python3/dist-packages/django/middleware/cache.pyrBszUpdateCacheMiddleware.__init__cCst|d�o|jS)N�_cache_update_cache)�hasattrr�r�request�responserrr�_should_update_cacheJsz*UpdateCacheMiddleware._should_update_cachecs���||�s|S|js|jdvr|S|js|jrt|d�r|Sd|�dd�vr)|S�j��durBt|���dur<�j	�n�dkrB|St
|���rx|jdkrxt||��j�j
d	��t|d
�rpt|j�rp|����fdd��|S�j
��|��|S)
zSet the cache, if needed.)��i0�Cookie�privatez
Cache-ControlrNrr$�r�rendercs�j��|��Sr)r�set)�r��	cache_keyr�timeoutrr�<lambda>psz8UpdateCacheMiddleware.process_response.<locals>.<lambda>)r#�	streaming�status_code�COOKIES�cookiesr�getrrrr	rrrr�callabler(�add_post_render_callbackr)r rr+r�process_responseMs2
��z&UpdateCacheMiddleware.process_responser)�__name__�
__module__�__qualname__�__doc__rr#r6�
__classcell__rrrrr7s

rcs*eZdZdZd�fdd�	Zdd�Z�ZS)�FetchFromCacheMiddlewarea!
    Request-phase cache middleware that fetches a page from the cache.

    Must be used as part of the two-part update/fetch cache middleware.
    FetchFromCacheMiddleware must be the last piece of middleware in MIDDLEWARE
    so that it'll get called last during the request phase.
    Ncs,t��|�tj|_tj|_t|j|_dSr)	r
rrrrrrrrrrrrr�sz!FetchFromCacheMiddleware.__init__cCs�|jdvr
d|_dSt||jd|jd�}|durd|_dS|j�|�}|dur<|jdkr<t||jd|jd�}|j�|�}|durEd|_dSd|_|S)zn
        Check whether the page is already cached and return the cached
        version if available.
        )�GET�HEADFNr=r'Tr>)�methodrrrrr3)rr!r,r"rrr�process_request�s 
z(FetchFromCacheMiddleware.process_requestr)r7r8r9r:rr@r;rrrrr<ws	r<cs"eZdZdZd�fdd�	Z�ZS)�CacheMiddlewarez�
    Cache middleware that provides basic behavior for many simple sites.

    Also used as the hook point for the cache decorator, which is generated
    using the decorator-from-middleware utility.
    Ncs�t��|�z|d}|durd}||_Wn	tyYnwz|d}|dur*t}||_t|j|_Wn	ty=Ynw|durE||_||_	dS)Nr�r)
r
rr�KeyErrorrrrrrr)rrrr�kwargsrrrrrr�s*
��
zCacheMiddleware.__init__)NNN)r7r8r9r:rr;rrrrrA�srAN)r:�django.confr�django.core.cacherr�django.utils.cacherrrrr	�django.utils.deprecationr
rr<rArrrr�<module>s-@-