File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/decorators.tar
Back
__pycache__/__init__.cpython-310.pyc 0000644 00000000260 15030245611 0013207 0 ustar 00 o �h � @ s d S )N� r r r �S/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/__init__.py�<module> s __pycache__/debug.cpython-310.pyc 0000644 00000006250 15030245611 0012543 0 ustar 00 o �hE � @ s, d dl mZ d dlmZ dd� Zdd� ZdS )� ��wraps)� HttpRequestc �0 t � �dkrt� d �rtd��� fdd�}|S )a� Indicate which variables used in the decorated function are sensitive so that those variables can later be treated in a special way, for example by hiding them when logging unhandled exceptions. Accept two forms: * with specified variable names: @sensitive_variables('user', 'password', 'credit_card') def my_function(user): password = user.pass_word credit_card = user.credit_card_number ... * without any specified variable names, in which case consider all variables are sensitive: @sensitive_variables() def my_function() ... � r zzsensitive_variables() must be called to use it as a decorator, e.g., use @sensitive_variables(), not @sensitive_variables.c s t � �� ��fdd����S )Nc s �r��_ nd�_ � | i |��S )N�__ALL__)�sensitive_variables)� func_args� func_kwargs)�func�sensitive_variables_wrapper� variables� �P/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/debug.pyr $ s zKsensitive_variables.<locals>.decorator.<locals>.sensitive_variables_wrapperr )r �r )r r r � decorator# s z&sensitive_variables.<locals>.decorator��len�callable� TypeError)r r r r r r s � r c r )a� Indicate which POST parameters used in the decorated view are sensitive, so that those parameters can later be treated in a special way, for example by hiding them when logging unhandled exceptions. Accept two forms: * with specified parameters: @sensitive_post_parameters('password', 'credit_card') def my_view(request): pw = request.POST['password'] cc = request.POST['credit_card'] ... * without any specified parameters, in which case consider all variables are sensitive: @sensitive_post_parameters() def my_view(request) ... r r z�sensitive_post_parameters() must be called to use it as a decorator, e.g., use @sensitive_post_parameters(), not @sensitive_post_parameters.c s t � ��� fdd��}|S )Nc s: t | t�s td��� r� | _nd| _�| g|�R i |��S )Nz�sensitive_post_parameters didn't receive an HttpRequest object. If you are decorating a classmethod, make sure to use @method_decorator.r )� isinstancer r �sensitive_post_parameters)�request�args�kwargs)� parameters�viewr r �!sensitive_post_parameters_wrapperP s �zWsensitive_post_parameters.<locals>.decorator.<locals>.sensitive_post_parameters_wrapperr )r r �r )r r r O s z,sensitive_post_parameters.<locals>.decoratorr )r r r r r r 1 s � r N)� functoolsr � django.httpr r r r r r r �<module> s + __pycache__/csrf.cpython-310.pyc 0000644 00000004310 15030245611 0012405 0 ustar 00 o �h � @ s� d dl mZ d dlmZmZ d dlmZ ee�Zde_de_ G dd� de�Z ee �Z de _d e _ G d d � d e�Z ee �Z d e _d e _ dd� ZdS )� )�wraps)�CsrfViewMiddleware� get_token)�decorator_from_middleware� csrf_protectz� This decorator adds CSRF protection in exactly the same way as CsrfViewMiddleware, but it can be used on a per view basis. Using both, or using the decorator multiple times, is harmless and efficient. c @ s e Zd Zdd� ZdS )�_EnsureCsrfTokenc C � d S �N� ��self�request�reasonr r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/csrf.py�_reject � z_EnsureCsrfToken._rejectN)�__name__� __module__� __qualname__r r r r r r s r �requires_csrf_tokenz� Use this decorator on views that need a correct csrf_token available to RequestContext, but without the CSRF protection that csrf_protect enforces. c s$ e Zd Zdd� Z� fdd�Z� ZS )�_EnsureCsrfCookiec C r r r r r r r r r z_EnsureCsrfCookie._rejectc s t � �||||�}t|� |S r )�super� process_viewr )r r �callback� callback_args�callback_kwargs�retval�� __class__r r r " s z _EnsureCsrfCookie.process_view)r r r r r � __classcell__r r r r r s r �ensure_csrf_cookiez� Use this decorator to ensure that a view sets a CSRF cookie, whether or not it uses the csrf_token template tag, or the CsrfViewMiddleware is used. c s t � �� fdd��}d|_|S )zCMark a view function as being exempt from the CSRF view protection.c s � | i |��S r r )�args�kwargs�� view_funcr r � wrapper_view6 s z!csrf_exempt.<locals>.wrapper_viewT)r � csrf_exempt)r$ r% r r# r r& 1 s r& N)� functoolsr �django.middleware.csrfr r �django.utils.decoratorsr r r �__doc__r r r r r& r r r r �<module> s __pycache__/gzip.cpython-310.pyc 0000644 00000000631 15030245611 0012423 0 ustar 00 o �h� � @ s* d dl mZ d dlmZ ee�Zde_dS )� )�GZipMiddleware)�decorator_from_middlewarez?Decorator for views that gzips pages if the client supports it.N)�django.middleware.gzipr �django.utils.decoratorsr � gzip_page�__doc__� r r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/gzip.py�<module> s __pycache__/clickjacking.cpython-310.pyc 0000644 00000003442 15030245611 0014071 0 ustar 00 o �h/ � @ s( d dl mZ dd� Zdd� Zdd� ZdS ) � ��wrapsc � t � �� fdd��}|S )z� Modify a view function so its response has the X-Frame-Options HTTP header set to 'DENY' as long as the response doesn't already have that header set. Usage: @xframe_options_deny def some_view(request): ... c �( � | i |��}|� d�d u rd|d< |S )N�X-Frame-Options�DENY��get��args�kwargs�resp�� view_func� �W/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/clickjacking.py� wrapper_view � z)xframe_options_deny.<locals>.wrapper_viewr �r r r r r �xframe_options_deny � r c r )z� Modify a view function so its response has the X-Frame-Options HTTP header set to 'SAMEORIGIN' as long as the response doesn't already have that header set. Usage: @xframe_options_sameorigin def some_view(request): ... c r )Nr � SAMEORIGINr r r r r r $ r z/xframe_options_sameorigin.<locals>.wrapper_viewr r r r r �xframe_options_sameorigin r r c r )z� Modify a view function by setting a response variable that instructs XFrameOptionsMiddleware to NOT set the X-Frame-Options HTTP header. Usage: @xframe_options_exempt def some_view(request): ... c s � | i |��}d|_ |S )NT)�xframe_options_exemptr r r r r 8 s z+xframe_options_exempt.<locals>.wrapper_viewr r r r r r . s r N)� functoolsr r r r r r r r �<module> s __pycache__/cache.cpython-310.pyc 0000644 00000004740 15030245611 0012522 0 ustar 00 o �h$ � @ sX d dl mZ d dlmZ d dlmZmZ d dlmZ ddd�dd�Z d d � Z d d � Z dS ) � ��wraps)�CacheMiddleware)�add_never_cache_headers�patch_cache_control)�#decorator_from_middleware_with_argsN)�cache� key_prefixc C s t t�| ||d�S )a9 Decorator for views that tries getting the page from the cache and populates the cache if the page isn't in the cache yet. The cache is keyed by the URL and some data from the headers. Additionally there is the key prefix that is used to distinguish different cache areas in a multi-site setup. You could use the get_current_site().domain, for example, as that is unique across a Django project. Additionally, all headers from the response's Vary header will be taken into account on caching -- just like the middleware does. )� page_timeout� cache_aliasr )r r )�timeoutr r � r �P/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/cache.py� cache_page s �r c s � fdd�}|S )Nc s t � ��� fdd��}|S )Nc s< t | d�s td���| g|�R i |��}t|fi � �� |S )N�METAzscache_control didn't receive an HttpRequest. If you are decorating a classmethod, be sure to use @method_decorator.)�hasattr� TypeErrorr )�request�args�kw�response)�kwargs�viewfuncr r �_cache_controlled s �zCcache_control.<locals>._cache_controller.<locals>._cache_controlledr )r r �r )r r �_cache_controller s z(cache_control.<locals>._cache_controllerr )r r r r r � cache_control s r c s t � �� fdd��}|S )zT Decorator that adds headers to a response so that it will never be cached. c s4 t | d�s td��� | g|�R i |��}t|� |S )Nr zqnever_cache didn't receive an HttpRequest. If you are decorating a classmethod, be sure to use @method_decorator.)r r r )r r r r �� view_funcr r �_wrapper_view_func6 s �z'never_cache.<locals>._wrapper_view_funcr )r r r r r � never_cache1 s r ) � functoolsr �django.middleware.cacher �django.utils.cacher r �django.utils.decoratorsr r r r r r r r �<module> s __pycache__/http.cpython-310.pyc 0000644 00000010636 15030245611 0012437 0 ustar 00 o �hC � @ s� d Z ddlZddlmZ ddlmZ ddlmZ ddlm Z ddl m Z ddl m Z dd lmZmZ dd lmZ e e�Zd d � Zed g�Zde_ edg�Zde_ ed dg�Zde_ ddd�Zdd� Zdd� ZdS )z- Decorators for views based on HTTP headers. � N��wraps)�HttpResponseNotAllowed)�ConditionalGetMiddleware)�timezone)�get_conditional_response)�decorator_from_middleware)� http_date� quote_etag)� log_responsec s � fdd�}|S )a9 Decorator to make a view only accept particular request methods. Usage:: @require_http_methods(["GET", "POST"]) def my_view(request): # I can assume now that only GET or POST requests make it this far # ... Note that request methods should be in uppercase. c s t � �� �fdd��}|S )Nc sB | j �vrt��}td| j | j|| d� |S � | g|�R i |��S )NzMethod Not Allowed (%s): %s)�response�request)�methodr r �path)r �args�kwargsr )�func�request_method_list� �O/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/http.py�inner s �z6require_http_methods.<locals>.decorator.<locals>.innerr �r r �r �r r � decorator s z'require_http_methods.<locals>.decoratorr )r r r r r �require_http_methods s r �GETz=Decorator to require that a view only accepts the GET method.�POSTz>Decorator to require that a view only accepts the POST method.�HEADzIDecorator to require that a view only accepts safe methods: GET and HEAD.c s � �fdd�}|S )ak Decorator to support conditional retrieval (or change) for a view function. The parameters are callables to compute the ETag and last modified time for the requested resource, respectively. The callables are passed the same parameters as the view itself. The ETag function should return a string (or None if the resource doesn't exist), while the last_modified function should return a datetime object (or None if the resource doesn't exist). The ETag function should return a complete ETag, including quotes (e.g. '"etag"'), since that's the only way to distinguish between weak and strong ETags. If an unquoted ETag is returned (e.g. 'etag'), it will be converted to a strong ETag by adding quotes. This decorator will either pass control to the wrapped view function or return an HTTP 304 response (unmodified) or 412 response (precondition failed), depending upon the request method. In either case, the decorator will add the generated ETag and Last-Modified headers to the response if the headers aren't already set and if the request's method is safe. c s t � ��� �fdd��}|S )Nc s� � ���fdd�}�r��g� �R i ���nd }|d ur t |�nd }|� }t�||d�}|d u r;��g� �R i ���}�jdv rW|rN|�d�sNt|�|jd< |rW|j�d|� |S )Nc sL �r"��g� �R i ���} | r$t �| �s t �| tj j�} t| �� �S d S d S )N)r �is_aware� make_aware�datetime�utc�int� timestamp)�dt)r r �last_modified_funcr r r �get_last_modifiedY s �zFcondition.<locals>.decorator.<locals>.inner.<locals>.get_last_modified)�etag� last_modified)r r z Last-Modified�ETag)r r r � has_headerr �headers� setdefault)r r r r' �res_etag�res_last_modifiedr )� etag_funcr r& )r r r r r V s" � z+condition.<locals>.decorator.<locals>.innerr r �r0 r& r r r U s "z condition.<locals>.decoratorr )r0 r& r r r1 r � condition> s &r2 c C � t | d�S )N�r0 �r2 r4 r r r r( � r( c C r3 )N�r& r5 r7 r r r r) � r6 r) )NN)�__doc__r! � functoolsr � django.httpr �django.middleware.httpr � django.utilsr �django.utils.cacher �django.utils.decoratorsr �django.utils.httpr r �django.utils.logr �conditional_pager � require_GET� require_POST� require_safer2 r( r) r r r r �<module> s, � A __pycache__/vary.cpython-310.pyc 0000644 00000002760 15030245611 0012440 0 ustar 00 o �hA � @ s, d dl mZ d dlmZ dd� Zdd� ZdS )� ��wraps��patch_vary_headersc s � fdd�}|S )a A view decorator that adds the specified headers to the Vary header of the response. Usage: @vary_on_headers('Cookie', 'Accept-language') def index(request): ... Note that the header names are not case-sensitive. c s t � �� �fdd��}|S )Nc s � | i |��}t |�� |S )Nr ��args�kwargs�response)�func�headers� �O/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/vary.py� inner_func � z6vary_on_headers.<locals>.decorator.<locals>.inner_funcr �r r �r �r r � decorator s z"vary_on_headers.<locals>.decoratorr )r r r r r �vary_on_headers s r c s t � �� fdd��}|S )z� A view decorator that adds "Cookie" to the Vary header of a response. This indicates that a page's contents depends on cookies. Usage: @vary_on_cookie def index(request): ... c s � | i |��}t |d� |S )N)�Cookier r r r r r ( r z"vary_on_cookie.<locals>.inner_funcr r r r r �vary_on_cookie s r N)� functoolsr �django.utils.cacher r r r r r r �<module> s __pycache__/common.cpython-310.pyc 0000644 00000001176 15030245611 0012747 0 ustar 00 o �h� � @ s d dl mZ dd� ZdS )� )�wrapsc s t � �� fdd��}d|_|S )z` Mark a view function as excluded from CommonMiddleware's APPEND_SLASH redirection. c s � | i |��S )N� )�args�kwargs�� view_funcr �Q/usr/local/CyberCP/lib/python3.10/site-packages/django/views/decorators/common.py� wrapper_view s z%no_append_slash.<locals>.wrapper_viewF)r �should_append_slash)r r r r r �no_append_slash s r N)� functoolsr r r r r r �<module> s gzip.py 0000644 00000000375 15030245611 0006071 0 ustar 00 from django.middleware.gzip import GZipMiddleware from django.utils.decorators import decorator_from_middleware gzip_page = decorator_from_middleware(GZipMiddleware) gzip_page.__doc__ = "Decorator for views that gzips pages if the client supports it." debug.py 0000644 00000006105 15030245611 0006203 0 ustar 00 from functools import wraps from django.http import HttpRequest def sensitive_variables(*variables): """ Indicate which variables used in the decorated function are sensitive so that those variables can later be treated in a special way, for example by hiding them when logging unhandled exceptions. Accept two forms: * with specified variable names: @sensitive_variables('user', 'password', 'credit_card') def my_function(user): password = user.pass_word credit_card = user.credit_card_number ... * without any specified variable names, in which case consider all variables are sensitive: @sensitive_variables() def my_function() ... """ if len(variables) == 1 and callable(variables[0]): raise TypeError( "sensitive_variables() must be called to use it as a decorator, " "e.g., use @sensitive_variables(), not @sensitive_variables." ) def decorator(func): @wraps(func) def sensitive_variables_wrapper(*func_args, **func_kwargs): if variables: sensitive_variables_wrapper.sensitive_variables = variables else: sensitive_variables_wrapper.sensitive_variables = "__ALL__" return func(*func_args, **func_kwargs) return sensitive_variables_wrapper return decorator def sensitive_post_parameters(*parameters): """ Indicate which POST parameters used in the decorated view are sensitive, so that those parameters can later be treated in a special way, for example by hiding them when logging unhandled exceptions. Accept two forms: * with specified parameters: @sensitive_post_parameters('password', 'credit_card') def my_view(request): pw = request.POST['password'] cc = request.POST['credit_card'] ... * without any specified parameters, in which case consider all variables are sensitive: @sensitive_post_parameters() def my_view(request) ... """ if len(parameters) == 1 and callable(parameters[0]): raise TypeError( "sensitive_post_parameters() must be called to use it as a " "decorator, e.g., use @sensitive_post_parameters(), not " "@sensitive_post_parameters." ) def decorator(view): @wraps(view) def sensitive_post_parameters_wrapper(request, *args, **kwargs): if not isinstance(request, HttpRequest): raise TypeError( "sensitive_post_parameters didn't receive an HttpRequest " "object. If you are decorating a classmethod, make sure " "to use @method_decorator." ) if parameters: request.sensitive_post_parameters = parameters else: request.sensitive_post_parameters = "__ALL__" return view(request, *args, **kwargs) return sensitive_post_parameters_wrapper return decorator vary.py 0000644 00000002101 15030245611 0006066 0 ustar 00 from functools import wraps from django.utils.cache import patch_vary_headers def vary_on_headers(*headers): """ A view decorator that adds the specified headers to the Vary header of the response. Usage: @vary_on_headers('Cookie', 'Accept-language') def index(request): ... Note that the header names are not case-sensitive. """ def decorator(func): @wraps(func) def inner_func(*args, **kwargs): response = func(*args, **kwargs) patch_vary_headers(response, headers) return response return inner_func return decorator def vary_on_cookie(func): """ A view decorator that adds "Cookie" to the Vary header of a response. This indicates that a page's contents depends on cookies. Usage: @vary_on_cookie def index(request): ... """ @wraps(func) def inner_func(*args, **kwargs): response = func(*args, **kwargs) patch_vary_headers(response, ("Cookie",)) return response return inner_func cache.py 0000644 00000004444 15030245611 0006164 0 ustar 00 from functools import wraps from django.middleware.cache import CacheMiddleware from django.utils.cache import add_never_cache_headers, patch_cache_control from django.utils.decorators import decorator_from_middleware_with_args def cache_page(timeout, *, cache=None, key_prefix=None): """ Decorator for views that tries getting the page from the cache and populates the cache if the page isn't in the cache yet. The cache is keyed by the URL and some data from the headers. Additionally there is the key prefix that is used to distinguish different cache areas in a multi-site setup. You could use the get_current_site().domain, for example, as that is unique across a Django project. Additionally, all headers from the response's Vary header will be taken into account on caching -- just like the middleware does. """ return decorator_from_middleware_with_args(CacheMiddleware)( page_timeout=timeout, cache_alias=cache, key_prefix=key_prefix, ) def cache_control(**kwargs): def _cache_controller(viewfunc): @wraps(viewfunc) def _cache_controlled(request, *args, **kw): # Ensure argument looks like a request. if not hasattr(request, "META"): raise TypeError( "cache_control didn't receive an HttpRequest. If you are " "decorating a classmethod, be sure to use " "@method_decorator." ) response = viewfunc(request, *args, **kw) patch_cache_control(response, **kwargs) return response return _cache_controlled return _cache_controller def never_cache(view_func): """ Decorator that adds headers to a response so that it will never be cached. """ @wraps(view_func) def _wrapper_view_func(request, *args, **kwargs): # Ensure argument looks like a request. if not hasattr(request, "META"): raise TypeError( "never_cache didn't receive an HttpRequest. If you are " "decorating a classmethod, be sure to use @method_decorator." ) response = view_func(request, *args, **kwargs) add_never_cache_headers(response) return response return _wrapper_view_func csrf.py 0000644 00000004037 15030245611 0006054 0 ustar 00 from functools import wraps from django.middleware.csrf import CsrfViewMiddleware, get_token from django.utils.decorators import decorator_from_middleware csrf_protect = decorator_from_middleware(CsrfViewMiddleware) csrf_protect.__name__ = "csrf_protect" csrf_protect.__doc__ = """ This decorator adds CSRF protection in exactly the same way as CsrfViewMiddleware, but it can be used on a per view basis. Using both, or using the decorator multiple times, is harmless and efficient. """ class _EnsureCsrfToken(CsrfViewMiddleware): # Behave like CsrfViewMiddleware but don't reject requests or log warnings. def _reject(self, request, reason): return None requires_csrf_token = decorator_from_middleware(_EnsureCsrfToken) requires_csrf_token.__name__ = "requires_csrf_token" requires_csrf_token.__doc__ = """ Use this decorator on views that need a correct csrf_token available to RequestContext, but without the CSRF protection that csrf_protect enforces. """ class _EnsureCsrfCookie(CsrfViewMiddleware): def _reject(self, request, reason): return None def process_view(self, request, callback, callback_args, callback_kwargs): retval = super().process_view(request, callback, callback_args, callback_kwargs) # Force process_response to send the cookie get_token(request) return retval ensure_csrf_cookie = decorator_from_middleware(_EnsureCsrfCookie) ensure_csrf_cookie.__name__ = "ensure_csrf_cookie" ensure_csrf_cookie.__doc__ = """ Use this decorator to ensure that a view sets a CSRF cookie, whether or not it uses the csrf_token template tag, or the CsrfViewMiddleware is used. """ def csrf_exempt(view_func): """Mark a view function as being exempt from the CSRF view protection.""" # view_func.csrf_exempt = True would also work, but decorators are nicer # if they don't have side effects, so return a new function. @wraps(view_func) def wrapper_view(*args, **kwargs): return view_func(*args, **kwargs) wrapper_view.csrf_exempt = True return wrapper_view common.py 0000644 00000000756 15030245611 0006413 0 ustar 00 from functools import wraps def no_append_slash(view_func): """ Mark a view function as excluded from CommonMiddleware's APPEND_SLASH redirection. """ # view_func.should_append_slash = False would also work, but decorators are # nicer if they don't have side effects, so return a new function. @wraps(view_func) def wrapper_view(*args, **kwargs): return view_func(*args, **kwargs) wrapper_view.should_append_slash = False return wrapper_view clickjacking.py 0000644 00000003057 15030245611 0007534 0 ustar 00 from functools import wraps def xframe_options_deny(view_func): """ Modify a view function so its response has the X-Frame-Options HTTP header set to 'DENY' as long as the response doesn't already have that header set. Usage: @xframe_options_deny def some_view(request): ... """ @wraps(view_func) def wrapper_view(*args, **kwargs): resp = view_func(*args, **kwargs) if resp.get("X-Frame-Options") is None: resp["X-Frame-Options"] = "DENY" return resp return wrapper_view def xframe_options_sameorigin(view_func): """ Modify a view function so its response has the X-Frame-Options HTTP header set to 'SAMEORIGIN' as long as the response doesn't already have that header set. Usage: @xframe_options_sameorigin def some_view(request): ... """ @wraps(view_func) def wrapper_view(*args, **kwargs): resp = view_func(*args, **kwargs) if resp.get("X-Frame-Options") is None: resp["X-Frame-Options"] = "SAMEORIGIN" return resp return wrapper_view def xframe_options_exempt(view_func): """ Modify a view function by setting a response variable that instructs XFrameOptionsMiddleware to NOT set the X-Frame-Options HTTP header. Usage: @xframe_options_exempt def some_view(request): ... """ @wraps(view_func) def wrapper_view(*args, **kwargs): resp = view_func(*args, **kwargs) resp.xframe_options_exempt = True return resp return wrapper_view __init__.py 0000644 00000000000 15030245611 0006640 0 ustar 00 http.py 0000644 00000011503 15030245611 0006072 0 ustar 00 """ Decorators for views based on HTTP headers. """ import datetime from functools import wraps from django.http import HttpResponseNotAllowed from django.middleware.http import ConditionalGetMiddleware from django.utils import timezone from django.utils.cache import get_conditional_response from django.utils.decorators import decorator_from_middleware from django.utils.http import http_date, quote_etag from django.utils.log import log_response conditional_page = decorator_from_middleware(ConditionalGetMiddleware) def require_http_methods(request_method_list): """ Decorator to make a view only accept particular request methods. Usage:: @require_http_methods(["GET", "POST"]) def my_view(request): # I can assume now that only GET or POST requests make it this far # ... Note that request methods should be in uppercase. """ def decorator(func): @wraps(func) def inner(request, *args, **kwargs): if request.method not in request_method_list: response = HttpResponseNotAllowed(request_method_list) log_response( "Method Not Allowed (%s): %s", request.method, request.path, response=response, request=request, ) return response return func(request, *args, **kwargs) return inner return decorator require_GET = require_http_methods(["GET"]) require_GET.__doc__ = "Decorator to require that a view only accepts the GET method." require_POST = require_http_methods(["POST"]) require_POST.__doc__ = "Decorator to require that a view only accepts the POST method." require_safe = require_http_methods(["GET", "HEAD"]) require_safe.__doc__ = ( "Decorator to require that a view only accepts safe methods: GET and HEAD." ) def condition(etag_func=None, last_modified_func=None): """ Decorator to support conditional retrieval (or change) for a view function. The parameters are callables to compute the ETag and last modified time for the requested resource, respectively. The callables are passed the same parameters as the view itself. The ETag function should return a string (or None if the resource doesn't exist), while the last_modified function should return a datetime object (or None if the resource doesn't exist). The ETag function should return a complete ETag, including quotes (e.g. '"etag"'), since that's the only way to distinguish between weak and strong ETags. If an unquoted ETag is returned (e.g. 'etag'), it will be converted to a strong ETag by adding quotes. This decorator will either pass control to the wrapped view function or return an HTTP 304 response (unmodified) or 412 response (precondition failed), depending upon the request method. In either case, the decorator will add the generated ETag and Last-Modified headers to the response if the headers aren't already set and if the request's method is safe. """ def decorator(func): @wraps(func) def inner(request, *args, **kwargs): # Compute values (if any) for the requested resource. def get_last_modified(): if last_modified_func: dt = last_modified_func(request, *args, **kwargs) if dt: if not timezone.is_aware(dt): dt = timezone.make_aware(dt, datetime.timezone.utc) return int(dt.timestamp()) # The value from etag_func() could be quoted or unquoted. res_etag = etag_func(request, *args, **kwargs) if etag_func else None res_etag = quote_etag(res_etag) if res_etag is not None else None res_last_modified = get_last_modified() response = get_conditional_response( request, etag=res_etag, last_modified=res_last_modified, ) if response is None: response = func(request, *args, **kwargs) # Set relevant headers on the response if they don't already exist # and if the request method is safe. if request.method in ("GET", "HEAD"): if res_last_modified and not response.has_header("Last-Modified"): response.headers["Last-Modified"] = http_date(res_last_modified) if res_etag: response.headers.setdefault("ETag", res_etag) return response return inner return decorator # Shortcut decorators for common cases based on ETag or Last-Modified only def etag(etag_func): return condition(etag_func=etag_func) def last_modified(last_modified_func): return condition(last_modified_func=last_modified_func)
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings