File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/messages.zip
Back
PK w��Z+��� views.pynu �[��� from django.contrib import messages class SuccessMessageMixin: """ Add a success message on successful form submission. """ success_message = "" def form_valid(self, form): response = super().form_valid(form) success_message = self.get_success_message(form.cleaned_data) if success_message: messages.success(self.request, success_message) return response def get_success_message(self, cleaned_data): return self.success_message % cleaned_data PK w��Zk��8 8 constants.pynu �[��� DEBUG = 10 INFO = 20 SUCCESS = 25 WARNING = 30 ERROR = 40 DEFAULT_TAGS = { DEBUG: "debug", INFO: "info", SUCCESS: "success", WARNING: "warning", ERROR: "error", } DEFAULT_LEVELS = { "DEBUG": DEBUG, "INFO": INFO, "SUCCESS": SUCCESS, "WARNING": WARNING, "ERROR": ERROR, } PK w��Z2 �� $ __pycache__/__init__.cpython-310.pycnu �[��� o �hj � @ s d dl T d dlT dS )� )�*N)�django.contrib.messages.api�!django.contrib.messages.constants� r r �S/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/__init__.py�<module> s PK w��Z���(@ @ . __pycache__/context_processors.cpython-310.pycnu �[��� o �hb � @ s$ d dl mZ d dlmZ dd� ZdS )� )� get_messages)�DEFAULT_LEVELSc C s t | �td�S )z\ Return a lazy 'messages' context variable as well as 'DEFAULT_MESSAGE_LEVELS'. )�messages�DEFAULT_MESSAGE_LEVELS)r r )�request� r �]/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/context_processors.pyr s �r N)�django.contrib.messages.apir �!django.contrib.messages.constantsr r r r r r �<module> s PK w��Z��(�� � % __pycache__/constants.cpython-310.pycnu �[��� o �h8 � @ s@ d Z dZdZdZdZe dedededed iZe eeeed �Zd S ) � � � � �( �debug�info�success�warning�error)�DEBUG�INFO�SUCCESS�WARNING�ERRORN)r r r r r � DEFAULT_TAGS�DEFAULT_LEVELS� r r �T/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/constants.py�<module> s" � �PK w��Z���_] ] __pycache__/api.cpython-310.pycnu �[��� o �h� � @ s� d dl mZ d dlmZ dZG dd� de�Zddd �Zd d � Zd d � Z dd� Z ddd�Z ddd�Z ddd�Z ddd�Zddd�ZdS ) � )� constants)�default_storage) � add_message� get_messages� get_level� set_level�debug�info�success�warning�error�MessageFailurec @ s e Zd ZdS )r N)�__name__� __module__� __qualname__� r r �N/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/api.pyr s r � Fc C sT z| j }W n ty" t| d�std| jj ��|s td��Y dS w |�|||�S )zK Attempt to add a message to the request using the 'messages' app. �METAz?add_message() argument must be an HttpRequest object, not '%s'.z_You cannot add messages without installing django.contrib.messages.middleware.MessageMiddlewareN)� _messages�AttributeError�hasattr� TypeError� __class__r r �add)�request�level�message� extra_tags� fail_silently�messagesr r r r s ����� r c C s t | dg �S )ze Return the message storage on the request if it exists, otherwise return an empty list. r )�getattr)r r r r r + s r c C s t | dt| ��}|jS )z� Return the minimum level of messages to be recorded. The default level is the ``MESSAGE_LEVEL`` setting. If this is not found, use the ``INFO`` level. r )r! r r )r �storager r r r 3 s r c C s t | d�sdS || j_dS )z� Set the minimum level of messages to be recorded, and return ``True`` if the level was recorded successfully. If set to ``None``, use the default level (see the get_level() function). r FT)r r r )r r r r r r > s r c C � t | tj|||d� dS )z'Add a message with the ``DEBUG`` level.�r r N)r r �DEBUG�r r r r r r r r K � �r c C r# )z&Add a message with the ``INFO`` level.r$ N)r r �INFOr& r r r r V r' r c C r# )z)Add a message with the ``SUCCESS`` level.r$ N)r r �SUCCESSr& r r r r a r' r c C r# )z)Add a message with the ``WARNING`` level.r$ N)r r �WARNINGr& r r r r l r' r c C r# )z'Add a message with the ``ERROR`` level.r$ N)r r �ERRORr& r r r r w r' r N)r F)�django.contrib.messagesr � django.contrib.messages.storager �__all__� Exceptionr r r r r r r r r r r r r r �<module> s PK w��ZI�3'� � ! __pycache__/utils.cpython-310.pycnu �[��� o �h � @ s$ d dl mZ d dlmZ dd� ZdS )� )�settings)� constantsc C s i t j�ttdi ��S )z( Return the message level tags. � MESSAGE_TAGS)r � DEFAULT_TAGS�getattrr � r r �P/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/utils.py�get_level_tags s � �r N)� django.confr �django.contrib.messagesr r r r r r �<module> s PK w��Z���i __pycache__/apps.cpython-310.pycnu �[��� o �h � @ sX d dl mZ d dlmZ d dlmZ d dlmZ d dlm Z dd� Z G dd � d e�Z d S ) � )� AppConfig)�base)�get_level_tags)�setting_changed)� gettext_lazyc K s | dkr t � t_d S d S )N� MESSAGE_TAGS)r r � LEVEL_TAGS)�setting�kwargs� r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/apps.py�update_level_tags s �r c @ s e Zd ZdZed�Zdd� ZdS )�MessagesConfigzdjango.contrib.messages�Messagesc C s t �t� d S )N)r �connectr )�selfr r r �ready s zMessagesConfig.readyN)�__name__� __module__� __qualname__�name�_� verbose_namer r r r r r s r N) � django.appsr � django.contrib.messages.storager � django.contrib.messages.utilsr �django.core.signalsr �django.utils.translationr r r r r r r r �<module> s PK w��Z��9�� � & __pycache__/middleware.cpython-310.pycnu �[��� o �h� � @ s8 d dl mZ d dlmZ d dlmZ G dd� de�ZdS )� )�settings)�default_storage)�MiddlewareMixinc @ s e Zd ZdZdd� Zdd� ZdS )�MessageMiddlewarez5 Middleware that handles temporary messages. c C s t |�|_d S )N)r � _messages)�self�request� r �U/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/middleware.py�process_request s z!MessageMiddleware.process_requestc C s, t |d�r|j�|�}|rtjrtd��|S )z� Update the storage backend (i.e., save the messages). Raise ValueError if not all messages could be stored and DEBUG is True. r z+Not all temporary messages could be stored.)�hasattrr �updater �DEBUG� ValueError)r r �response�unstored_messagesr r r �process_response s z"MessageMiddleware.process_responseN)�__name__� __module__� __qualname__�__doc__r r r r r r r s r N)� django.confr � django.contrib.messages.storager �django.utils.deprecationr r r r r r �<module> s PK w��Z깨� � ! __pycache__/views.cpython-310.pycnu �[��� o �h � @ s d dl mZ G dd� d�ZdS )� )�messagesc s, e Zd ZdZdZ� fdd�Zdd� Z� ZS )�SuccessMessageMixinz> Add a success message on successful form submission. � c s. t � �|�}| �|j�}|rt�| j|� |S �N)�super� form_valid�get_success_message� cleaned_datar �success�request)�self�form�response�success_message�� __class__� �P/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/views.pyr s z SuccessMessageMixin.form_validc C s | j | S r )r )r r r r r r s z'SuccessMessageMixin.get_success_message)�__name__� __module__� __qualname__�__doc__r r r � __classcell__r r r r r s r N)�django.contribr r r r r r �<module> s PK w��Z���� � middleware.pynu �[��� from django.conf import settings from django.contrib.messages.storage import default_storage from django.utils.deprecation import MiddlewareMixin class MessageMiddleware(MiddlewareMixin): """ Middleware that handles temporary messages. """ def process_request(self, request): request._messages = default_storage(request) def process_response(self, request, response): """ Update the storage backend (i.e., save the messages). Raise ValueError if not all messages could be stored and DEBUG is True. """ # A higher middleware layer may return a request which does not contain # messages storage, so make no assumption that it will be there. if hasattr(request, "_messages"): unstored_messages = request._messages.update(response) if unstored_messages and settings.DEBUG: raise ValueError("Not all temporary messages could be stored.") return response PK w��ZZ��~� � api.pynu �[��� from django.contrib.messages import constants from django.contrib.messages.storage import default_storage __all__ = ( "add_message", "get_messages", "get_level", "set_level", "debug", "info", "success", "warning", "error", "MessageFailure", ) class MessageFailure(Exception): pass def add_message(request, level, message, extra_tags="", fail_silently=False): """ Attempt to add a message to the request using the 'messages' app. """ try: messages = request._messages except AttributeError: if not hasattr(request, "META"): raise TypeError( "add_message() argument must be an HttpRequest object, not " "'%s'." % request.__class__.__name__ ) if not fail_silently: raise MessageFailure( "You cannot add messages without installing " "django.contrib.messages.middleware.MessageMiddleware" ) else: return messages.add(level, message, extra_tags) def get_messages(request): """ Return the message storage on the request if it exists, otherwise return an empty list. """ return getattr(request, "_messages", []) def get_level(request): """ Return the minimum level of messages to be recorded. The default level is the ``MESSAGE_LEVEL`` setting. If this is not found, use the ``INFO`` level. """ storage = getattr(request, "_messages", default_storage(request)) return storage.level def set_level(request, level): """ Set the minimum level of messages to be recorded, and return ``True`` if the level was recorded successfully. If set to ``None``, use the default level (see the get_level() function). """ if not hasattr(request, "_messages"): return False request._messages.level = level return True def debug(request, message, extra_tags="", fail_silently=False): """Add a message with the ``DEBUG`` level.""" add_message( request, constants.DEBUG, message, extra_tags=extra_tags, fail_silently=fail_silently, ) def info(request, message, extra_tags="", fail_silently=False): """Add a message with the ``INFO`` level.""" add_message( request, constants.INFO, message, extra_tags=extra_tags, fail_silently=fail_silently, ) def success(request, message, extra_tags="", fail_silently=False): """Add a message with the ``SUCCESS`` level.""" add_message( request, constants.SUCCESS, message, extra_tags=extra_tags, fail_silently=fail_silently, ) def warning(request, message, extra_tags="", fail_silently=False): """Add a message with the ``WARNING`` level.""" add_message( request, constants.WARNING, message, extra_tags=extra_tags, fail_silently=fail_silently, ) def error(request, message, extra_tags="", fail_silently=False): """Add a message with the ``ERROR`` level.""" add_message( request, constants.ERROR, message, extra_tags=extra_tags, fail_silently=fail_silently, ) PK w��Z �� � storage/base.pynu �[��� from django.conf import settings from django.contrib.messages import constants, utils LEVEL_TAGS = utils.get_level_tags() class Message: """ Represent an actual message that can be stored in any of the supported storage classes (typically session- or cookie-based) and rendered in a view or template. """ def __init__(self, level, message, extra_tags=None): self.level = int(level) self.message = message self.extra_tags = extra_tags def _prepare(self): """ Prepare the message for serialization by forcing the ``message`` and ``extra_tags`` to str in case they are lazy translations. """ self.message = str(self.message) self.extra_tags = str(self.extra_tags) if self.extra_tags is not None else None def __eq__(self, other): if not isinstance(other, Message): return NotImplemented return self.level == other.level and self.message == other.message def __str__(self): return str(self.message) @property def tags(self): return " ".join(tag for tag in [self.extra_tags, self.level_tag] if tag) @property def level_tag(self): return LEVEL_TAGS.get(self.level, "") class BaseStorage: """ This is the base backend for temporary message storage. This is not a complete class; to be a usable storage backend, it must be subclassed and the two methods ``_get`` and ``_store`` overridden. """ def __init__(self, request, *args, **kwargs): self.request = request self._queued_messages = [] self.used = False self.added_new = False super().__init__(*args, **kwargs) def __len__(self): return len(self._loaded_messages) + len(self._queued_messages) def __iter__(self): self.used = True if self._queued_messages: self._loaded_messages.extend(self._queued_messages) self._queued_messages = [] return iter(self._loaded_messages) def __contains__(self, item): return item in self._loaded_messages or item in self._queued_messages def __repr__(self): return f"<{self.__class__.__qualname__}: request={self.request!r}>" @property def _loaded_messages(self): """ Return a list of loaded messages, retrieving them first if they have not been loaded yet. """ if not hasattr(self, "_loaded_data"): messages, all_retrieved = self._get() self._loaded_data = messages or [] return self._loaded_data def _get(self, *args, **kwargs): """ Retrieve a list of stored messages. Return a tuple of the messages and a flag indicating whether or not all the messages originally intended to be stored in this storage were, in fact, stored and retrieved; e.g., ``(messages, all_retrieved)``. **This method must be implemented by a subclass.** If it is possible to tell if the backend was not used (as opposed to just containing no messages) then ``None`` should be returned in place of ``messages``. """ raise NotImplementedError( "subclasses of BaseStorage must provide a _get() method" ) def _store(self, messages, response, *args, **kwargs): """ Store a list of messages and return a list of any messages which could not be stored. One type of object must be able to be stored, ``Message``. **This method must be implemented by a subclass.** """ raise NotImplementedError( "subclasses of BaseStorage must provide a _store() method" ) def _prepare_messages(self, messages): """ Prepare a list of messages for storage. """ for message in messages: message._prepare() def update(self, response): """ Store all unread messages. If the backend has yet to be iterated, store previously stored messages again. Otherwise, only store messages added after the last iteration. """ self._prepare_messages(self._queued_messages) if self.used: return self._store(self._queued_messages, response) elif self.added_new: messages = self._loaded_messages + self._queued_messages return self._store(messages, response) def add(self, level, message, extra_tags=""): """ Queue a message to be stored. The message is only queued if it contained something and its level is not less than the recording level (``self.level``). """ if not message: return # Check that the message level is not less than the recording level. level = int(level) if level < self.level: return # Add the message. self.added_new = True message = Message(level, message, extra_tags=extra_tags) self._queued_messages.append(message) def _get_level(self): """ Return the minimum recorded level. The default level is the ``MESSAGE_LEVEL`` setting. If this is not found, the ``INFO`` level is used. """ if not hasattr(self, "_level"): self._level = getattr(settings, "MESSAGE_LEVEL", constants.INFO) return self._level def _set_level(self, value=None): """ Set a custom minimum recorded level. If set to ``None``, the default level will be used (see the ``_get_level`` method). """ if value is None and hasattr(self, "_level"): del self._level else: self._level = int(value) level = property(_get_level, _set_level, _set_level) PK w��Z>�O� * storage/__pycache__/cookie.cpython-310.pycnu �[��� o �h� � @ s� d dl Z d dlZd dlmZ d dlmZmZ d dlmZ d dl m Z d dl m Z m Z G dd� dej�ZG d d � d ej�ZG d d � d �ZG d d� de�ZdS )� N)�settings)� BaseStorage�Message)�signing)� SimpleCookie)�SafeData� mark_safec s$ e Zd ZdZdZ� fdd�Z� ZS )�MessageEncoderzI Compactly serialize instances of the ``Message`` class as JSON. �__json_messagec sV t |t�r%t |jt�r dnd}| j||j|jg}|jd ur#|�|j� |S t� � |�S )N� r ) � isinstancer �messager � message_key�level� extra_tags�append�super�default)�self�obj� is_safedatar �� __class__� �Y/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/storage/cookie.pyr s zMessageEncoder.default)�__name__� __module__� __qualname__�__doc__r r � __classcell__r r r r r s r c s( e Zd ZdZdd� Z� fdd�Z� ZS )�MessageDecoderzE Decode JSON that includes serialized ``Message`` instances. c sz t |t�r+|r+|d tjkr"|d rt|d �|d< t|dd � � S � fdd�|D �S t |t�r;� fdd�|�� D �S |S ) Nr r � � c s g | ]}� � |��qS r ��process_messages)�.0�item�r r r � <listcomp>( s z3MessageDecoder.process_messages.<locals>.<listcomp>c s i | ] \}}|� � |��qS r r# )r% �key�valuer' r r � <dictcomp>* s z3MessageDecoder.process_messages.<locals>.<dictcomp>)r �listr r r r �dict�items�r r r r' r r$ " s z MessageDecoder.process_messagesc s t � j|fi |��}| �|�S )N)r �decoder$ )r �s�kwargs�decodedr r r r0 - s zMessageDecoder.decode)r r r r r$ r0 r r r r r r s r c @ s e Zd Zdd� Zdd� ZdS )�MessageSerializerc C s t j|dtd��d�S )N)�,�:)� separators�cls�latin-1)�json�dumpsr �encoder/ r r r r; 3 s ��zMessageSerializer.dumpsc C s t j|�d�td�S )Nr9 )r8 )r: �loadsr0 r �r �datar r r r= : s zMessageSerializer.loadsN)r r r r; r= r r r r r4 2 s r4 c s\ e Zd ZdZdZdZdZdZ� fdd�Zdd � Z d d � Z dd d�Z ddd�Z dd� Z � ZS )� CookieStoragez% Store messages in a cookie. �messagesi �__messagesnotfinished__zdjango.contrib.messagesc s& t � j|i |�� tj| jd�| _d S )N)�salt)r �__init__r �get_cookie_signer�key_salt�signer)r �argsr2 r r r rD K s zCookieStorage.__init__c O sF | j j�| j�}| �|�}|o|d | jk }|r |s |�� ||fS )a Retrieve a list of messages from the messages cookie. If the not_finished sentinel value is found at the end of the message list, remove it and return a result indicating that not all messages were retrieved by this storage. ���)�request�COOKIES�get� cookie_name�_decode� not_finished�pop)r rH r2 r? rA � all_retrievedr r r �_getO s zCookieStorage._getc C sJ |r|j | j|tjtjp dtjpdtjd� dS |j| jtjtjd� dS )zz Either set the cookie with the encoded data if there is any data to store, or delete the cookie. N)�domain�secure�httponly�samesite)rS rV )� set_cookierM r �SESSION_COOKIE_DOMAIN�SESSION_COOKIE_SECURE�SESSION_COOKIE_HTTPONLY�SESSION_COOKIE_SAMESITE� delete_cookie)r � encoded_data�responser r r �_update_cookie^ s � �z CookieStorage._update_cookieTc s� g }| � |�}| jrCt� � � fdd�}|rC||�| jkrC|r'|�|�d�� n|�d|�� � | j || jg |d�}|rC||�| jks | �||� |S )aT Store the messages to a cookie and return a list of any messages which could not be stored. If the encoded data is larger than ``max_cookie_size``, remove messages until the data fits (these are the messages which are returned), and add the not_finished sentinel value to indicate as much. c s t � �| �d �S )Nr )�len� value_encode)�val��cookier r � stored_length� s z+CookieStorage._store.<locals>.stored_lengthr )� encode_empty)�_encode�max_cookie_sizer r rP �insertrO r_ ) r rA r^ � remove_oldestrH r2 �unstored_messagesr] re r rc r �_stores s �� zCookieStorage._storeFc C s |s|r | j j|tdd�S dS )a Return an encoded version of the messages list which can be stored as plain text. Since the data will be retrieved from the client-side, the encoded data also contains a hash to ensure that the data was not tampered with. T)� serializer�compressN)rG � sign_objectr4 )r rA rf r r r rg � s ��zCookieStorage._encodec C sD |sdS z | j j|td�W S tjtjtjfy Y nw d| _ dS )z� Safely decode an encoded text stream back into a list of messages. If the encoded text stream contained an invalid hash or was in an invalid format, return None. N)rm T) rG � unsign_objectr4 r � BadSignature�binascii�Errorr: �JSONDecodeError�usedr> r r r rN � s �zCookieStorage._decode)T)F)r r r r rM rh rO rF rD rR r_ rl rg rN r r r r r r@ > s r@ )rr r: � django.confr �$django.contrib.messages.storage.baser r � django.corer � django.httpr �django.utils.safestringr r � JSONEncoderr � JSONDecoderr r4 r@ r r r r �<module> s PK w��Z��� , storage/__pycache__/fallback.cpython-310.pycnu �[��� o �h- � @ s8 d dl mZ d dlmZ d dlmZ G dd� de�ZdS )� )� BaseStorage)� CookieStorage)�SessionStoragec s8 e Zd ZdZeefZ� fdd�Zdd� Zdd� Z � Z S )�FallbackStoragezu Try to store all messages in the first backend. Store any unstored messages in each subsequent backend. c s6 t � j� i ��� � �fdd�| jD �| _t� | _d S )Nc s g | ] }|� i ����qS � r )�.0� storage_class��args�kwargsr �[/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/storage/fallback.py� <listcomp> s �z,FallbackStorage.__init__.<locals>.<listcomp>)�super�__init__�storage_classes�storages�set�_used_storages)�selfr r �� __class__r r r s � zFallbackStorage.__init__c O s^ g }| j D ]%}|�� \}}|du r ||fS |r | j�|� |�|� |r* ||fS q||fS )zJ Get a single list of messages from all storage backends. N)r �_getr �add�extend)r r r � all_messages�storage�messages� all_retrievedr r r r s � �zFallbackStorage._getc O sH | j D ] }|r|j||dd�}q|| jv r!|�g |� | j�|� q|S )z� Store the messages and return any unstored messages after trying all backends. For each storage backend, any messages not stored are passed on to the next backend. F)� remove_oldest)r �_storer �remove)r r �responser r r r r r r ( s �zFallbackStorage._store) �__name__� __module__� __qualname__�__doc__r r r r r r � __classcell__r r r r r s r N)�$django.contrib.messages.storage.baser �&django.contrib.messages.storage.cookier �'django.contrib.messages.storage.sessionr r r r r r �<module> s PK w��Z˝�L� � , storage/__pycache__/__init__.cpython-310.pycnu �[��� o �h� � @ s$ d dl mZ d dlmZ dd� ZdS )� )�settings)� import_stringc C s t tj�| �S )z� Callable with the same interface as the storage classes. This isn't just default_storage = import_string(settings.MESSAGE_STORAGE) to avoid accessing the settings at the module level. )r r �MESSAGE_STORAGE)�request� r �[/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/storage/__init__.py�default_storage s r N)� django.confr �django.utils.module_loadingr r r r r r �<module> s PK w��Z65) � � + storage/__pycache__/session.cpython-310.pycnu �[��� o �h� � @ sD d dl Z d dlmZ d dlmZmZ d dlmZ G dd� de�ZdS )� N)� BaseStorage)�MessageDecoder�MessageEncoder)�ImproperlyConfiguredc sD e Zd ZdZdZ� fdd�Zdd� Zdd� Zd d � Zd d � Z � Z S ) �SessionStoragezK Store messages in the session (that is, django.contrib.sessions). � _messagesc s0 t |d�s td��t� j|g|�R i |�� d S )N�sessionz�The session-based temporary message storage requires session middleware to be installed, and come before the message middleware in the MIDDLEWARE list.)�hasattrr �super�__init__)�self�request�args�kwargs�� __class__� �Z/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/storage/session.pyr s � zSessionStorage.__init__c O s | � | jj�| j��dfS )z� Retrieve a list of messages from the request's session. This storage always stores everything it is given, so return True for the all_retrieved flag. T)�deserialize_messagesr r �get� session_key)r r r r r r �_get s �zSessionStorage._getc O s2 |r| � |�| jj| j< g S | jj�| jd� g S )zD Store a list of messages to the request's session. N)�serialize_messagesr r r �pop)r �messages�responser r r r r �_store# s �zSessionStorage._storec C s t � }|�|�S )N)r �encode)r r �encoderr r r r - s z!SessionStorage.serialize_messagesc C s |rt |t�rtj|td�S |S )N)�cls)� isinstance�str�json�loadsr )r �datar r r r 1 s z#SessionStorage.deserialize_messages) �__name__� __module__� __qualname__�__doc__r r r r r r � __classcell__r r r r r s r ) r" �$django.contrib.messages.storage.baser �&django.contrib.messages.storage.cookier r �django.core.exceptionsr r r r r r �<module> s PK w��Z��5# # ( storage/__pycache__/base.cpython-310.pycnu �[��� o �h� � @ sD d dl mZ d dlmZmZ e�� ZG dd� d�ZG dd� d�ZdS )� )�settings)� constants�utilsc @ sJ e Zd ZdZddd�Zdd� Zdd� Zd d � Zed d � �Z ed d� �Z dS )�Messagez� Represent an actual message that can be stored in any of the supported storage classes (typically session- or cookie-based) and rendered in a view or template. Nc C s t |�| _|| _|| _d S �N)�int�level�message� extra_tags��selfr r r � r �W/usr/local/CyberCP/lib/python3.10/site-packages/django/contrib/messages/storage/base.py�__init__ s zMessage.__init__c C s0 t | j�| _| jdurt | j�| _dS d| _dS )z� Prepare the message for serialization by forcing the ``message`` and ``extra_tags`` to str in case they are lazy translations. N)�strr r �r r r r �_prepare s $zMessage._preparec C s& t |t�stS | j|jko| j|jkS r )� isinstancer �NotImplementedr r )r �otherr r r �__eq__ s zMessage.__eq__c C s t | j�S r )r r r r r r �__str__ s zMessage.__str__c C s d� dd� | j| jfD ��S )N� c s s � | ]}|r|V qd S r r )�.0�tagr r r � <genexpr>% s � z Message.tags.<locals>.<genexpr>)�joinr � level_tagr r r r �tags# s z Message.tagsc C s t �| jd�S )N� )� LEVEL_TAGS�getr r r r r r ' s zMessage.level_tagr ) �__name__� __module__� __qualname__�__doc__r r r r �propertyr r r r r r r s r c s� e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Zd d � Ze d d � �Z dd� Z dd� Z dd� Z dd� Zd dd�Zdd� Zd d d �Ze eee�Z� ZS ) � BaseStoragez� This is the base backend for temporary message storage. This is not a complete class; to be a usable storage backend, it must be subclassed and the two methods ``_get`` and ``_store`` overridden. c s. || _ g | _d| _d| _t� j|i |�� d S )NF)�request�_queued_messages�used� added_new�superr )r r( �args�kwargs�� __class__r r r 4 s zBaseStorage.__init__c C s t | j�t | j� S r )�len�_loaded_messagesr) r r r r �__len__; � zBaseStorage.__len__c C s* d| _ | jr| j�| j� g | _t| j�S )NT)r* r) r2 �extend�iterr r r r �__iter__> s zBaseStorage.__iter__c C s || j v p || jv S r )r2 r) )r �itemr r r � __contains__E r4 zBaseStorage.__contains__c C s d| j j� d| j�d�S )N�<z : request=�>)r0 r$ r( r r r r �__repr__H s zBaseStorage.__repr__c C s& t | d�s| �� \}}|pg | _| jS )zs Return a list of loaded messages, retrieving them first if they have not been loaded yet. � _loaded_data)�hasattr�_getr= )r �messages� all_retrievedr r r r2 K s z BaseStorage._loaded_messagesc O � t d��)a Retrieve a list of stored messages. Return a tuple of the messages and a flag indicating whether or not all the messages originally intended to be stored in this storage were, in fact, stored and retrieved; e.g., ``(messages, all_retrieved)``. **This method must be implemented by a subclass.** If it is possible to tell if the backend was not used (as opposed to just containing no messages) then ``None`` should be returned in place of ``messages``. z6subclasses of BaseStorage must provide a _get() method��NotImplementedError)r r- r. r r r r? V s �zBaseStorage._getc O rB )z� Store a list of messages and return a list of any messages which could not be stored. One type of object must be able to be stored, ``Message``. **This method must be implemented by a subclass.** z8subclasses of BaseStorage must provide a _store() methodrC )r r@ �responser- r. r r r �_storeg s �zBaseStorage._storec C s |D ]}|� � qdS )z9 Prepare a list of messages for storage. N)r )r r@ r r r r �_prepare_messagest s �z BaseStorage._prepare_messagesc C sB | � | j� | jr| �| j|�S | jr | j| j }| �||�S dS )z� Store all unread messages. If the backend has yet to be iterated, store previously stored messages again. Otherwise, only store messages added after the last iteration. N)rG r) r* rF r+ r2 )r rE r@ r r r �update{ s �zBaseStorage.updater c C sB |sdS t |�}|| jk rdS d| _t|||d�}| j�|� dS )z� Queue a message to be stored. The message is only queued if it contained something and its level is not less than the recording level (``self.level``). NT)r )r r r+ r r) �appendr r r r �add� s zBaseStorage.addc C s t | d�s ttdtj�| _| jS )z� Return the minimum recorded level. The default level is the ``MESSAGE_LEVEL`` setting. If this is not found, the ``INFO`` level is used. �_level� MESSAGE_LEVEL)r> �getattrr r �INFOrK r r r r � _get_level� s zBaseStorage._get_levelNc C s( |du r t | d�r | `dS t|�| _dS )z� Set a custom minimum recorded level. If set to ``None``, the default level will be used (see the ``_get_level`` method). NrK )r> rK r )r �valuer r r � _set_level� s zBaseStorage._set_level)r r )r" r# r$ r% r r3 r7 r9 r< r& r2 r? rF rG rH rJ rO rQ r � __classcell__r r r/ r r' , s" r' N) � django.confr �django.contrib.messagesr r �get_level_tagsr r r' r r r r �<module> s %PK w��ZTa�� � storage/cookie.pynu �[��� import binascii import json from django.conf import settings from django.contrib.messages.storage.base import BaseStorage, Message from django.core import signing from django.http import SimpleCookie from django.utils.safestring import SafeData, mark_safe class MessageEncoder(json.JSONEncoder): """ Compactly serialize instances of the ``Message`` class as JSON. """ message_key = "__json_message" def default(self, obj): if isinstance(obj, Message): # Using 0/1 here instead of False/True to produce more compact json is_safedata = 1 if isinstance(obj.message, SafeData) else 0 message = [self.message_key, is_safedata, obj.level, obj.message] if obj.extra_tags is not None: message.append(obj.extra_tags) return message return super().default(obj) class MessageDecoder(json.JSONDecoder): """ Decode JSON that includes serialized ``Message`` instances. """ def process_messages(self, obj): if isinstance(obj, list) and obj: if obj[0] == MessageEncoder.message_key: if obj[1]: obj[3] = mark_safe(obj[3]) return Message(*obj[2:]) return [self.process_messages(item) for item in obj] if isinstance(obj, dict): return {key: self.process_messages(value) for key, value in obj.items()} return obj def decode(self, s, **kwargs): decoded = super().decode(s, **kwargs) return self.process_messages(decoded) class MessageSerializer: def dumps(self, obj): return json.dumps( obj, separators=(",", ":"), cls=MessageEncoder, ).encode("latin-1") def loads(self, data): return json.loads(data.decode("latin-1"), cls=MessageDecoder) class CookieStorage(BaseStorage): """ Store messages in a cookie. """ cookie_name = "messages" # uwsgi's default configuration enforces a maximum size of 4kb for all the # HTTP headers. In order to leave some room for other cookies and headers, # restrict the session cookie to 1/2 of 4kb. See #18781. max_cookie_size = 2048 not_finished = "__messagesnotfinished__" key_salt = "django.contrib.messages" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.signer = signing.get_cookie_signer(salt=self.key_salt) def _get(self, *args, **kwargs): """ Retrieve a list of messages from the messages cookie. If the not_finished sentinel value is found at the end of the message list, remove it and return a result indicating that not all messages were retrieved by this storage. """ data = self.request.COOKIES.get(self.cookie_name) messages = self._decode(data) all_retrieved = not (messages and messages[-1] == self.not_finished) if messages and not all_retrieved: # remove the sentinel value messages.pop() return messages, all_retrieved def _update_cookie(self, encoded_data, response): """ Either set the cookie with the encoded data if there is any data to store, or delete the cookie. """ if encoded_data: response.set_cookie( self.cookie_name, encoded_data, domain=settings.SESSION_COOKIE_DOMAIN, secure=settings.SESSION_COOKIE_SECURE or None, httponly=settings.SESSION_COOKIE_HTTPONLY or None, samesite=settings.SESSION_COOKIE_SAMESITE, ) else: response.delete_cookie( self.cookie_name, domain=settings.SESSION_COOKIE_DOMAIN, samesite=settings.SESSION_COOKIE_SAMESITE, ) def _store(self, messages, response, remove_oldest=True, *args, **kwargs): """ Store the messages to a cookie and return a list of any messages which could not be stored. If the encoded data is larger than ``max_cookie_size``, remove messages until the data fits (these are the messages which are returned), and add the not_finished sentinel value to indicate as much. """ unstored_messages = [] encoded_data = self._encode(messages) if self.max_cookie_size: # data is going to be stored eventually by SimpleCookie, which # adds its own overhead, which we must account for. cookie = SimpleCookie() # create outside the loop def stored_length(val): return len(cookie.value_encode(val)[1]) while encoded_data and stored_length(encoded_data) > self.max_cookie_size: if remove_oldest: unstored_messages.append(messages.pop(0)) else: unstored_messages.insert(0, messages.pop()) encoded_data = self._encode( messages + [self.not_finished], encode_empty=unstored_messages ) self._update_cookie(encoded_data, response) return unstored_messages def _encode(self, messages, encode_empty=False): """ Return an encoded version of the messages list which can be stored as plain text. Since the data will be retrieved from the client-side, the encoded data also contains a hash to ensure that the data was not tampered with. """ if messages or encode_empty: return self.signer.sign_object( messages, serializer=MessageSerializer, compress=True ) def _decode(self, data): """ Safely decode an encoded text stream back into a list of messages. If the encoded text stream contained an invalid hash or was in an invalid format, return None. """ if not data: return None try: return self.signer.unsign_object(data, serializer=MessageSerializer) except (signing.BadSignature, binascii.Error, json.JSONDecodeError): pass # Mark the data as used (so it gets removed) since something was wrong # with the data. self.used = True return None PK w��ZkW�Q- - storage/fallback.pynu �[��� from django.contrib.messages.storage.base import BaseStorage from django.contrib.messages.storage.cookie import CookieStorage from django.contrib.messages.storage.session import SessionStorage class FallbackStorage(BaseStorage): """ Try to store all messages in the first backend. Store any unstored messages in each subsequent backend. """ storage_classes = (CookieStorage, SessionStorage) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.storages = [ storage_class(*args, **kwargs) for storage_class in self.storage_classes ] self._used_storages = set() def _get(self, *args, **kwargs): """ Get a single list of messages from all storage backends. """ all_messages = [] for storage in self.storages: messages, all_retrieved = storage._get() # If the backend hasn't been used, no more retrieval is necessary. if messages is None: break if messages: self._used_storages.add(storage) all_messages.extend(messages) # If this storage class contained all the messages, no further # retrieval is necessary if all_retrieved: break return all_messages, all_retrieved def _store(self, messages, response, *args, **kwargs): """ Store the messages and return any unstored messages after trying all backends. For each storage backend, any messages not stored are passed on to the next backend. """ for storage in self.storages: if messages: messages = storage._store(messages, response, remove_oldest=False) # Even if there are no more messages, continue iterating to ensure # storages which contained messages are flushed. elif storage in self._used_storages: storage._store([], response) self._used_storages.remove(storage) return messages PK w��ZMlR�� � storage/session.pynu �[��� import json from django.contrib.messages.storage.base import BaseStorage from django.contrib.messages.storage.cookie import MessageDecoder, MessageEncoder from django.core.exceptions import ImproperlyConfigured class SessionStorage(BaseStorage): """ Store messages in the session (that is, django.contrib.sessions). """ session_key = "_messages" def __init__(self, request, *args, **kwargs): if not hasattr(request, "session"): raise ImproperlyConfigured( "The session-based temporary message storage requires session " "middleware to be installed, and come before the message " "middleware in the MIDDLEWARE list." ) super().__init__(request, *args, **kwargs) def _get(self, *args, **kwargs): """ Retrieve a list of messages from the request's session. This storage always stores everything it is given, so return True for the all_retrieved flag. """ return ( self.deserialize_messages(self.request.session.get(self.session_key)), True, ) def _store(self, messages, response, *args, **kwargs): """ Store a list of messages to the request's session. """ if messages: self.request.session[self.session_key] = self.serialize_messages(messages) else: self.request.session.pop(self.session_key, None) return [] def serialize_messages(self, messages): encoder = MessageEncoder() return encoder.encode(messages) def deserialize_messages(self, data): if data and isinstance(data, str): return json.loads(data, cls=MessageDecoder) return data PK w��Z��X� � storage/__init__.pynu �[��� from django.conf import settings from django.utils.module_loading import import_string def default_storage(request): """ Callable with the same interface as the storage classes. This isn't just default_storage = import_string(settings.MESSAGE_STORAGE) to avoid accessing the settings at the module level. """ return import_string(settings.MESSAGE_STORAGE)(request) PK w��Ze�I� apps.pynu �[��� from django.apps import AppConfig from django.contrib.messages.storage import base from django.contrib.messages.utils import get_level_tags from django.core.signals import setting_changed from django.utils.translation import gettext_lazy as _ def update_level_tags(setting, **kwargs): if setting == "MESSAGE_TAGS": base.LEVEL_TAGS = get_level_tags() class MessagesConfig(AppConfig): name = "django.contrib.messages" verbose_name = _("Messages") def ready(self): setting_changed.connect(update_level_tags) PK w��Zr�c�b b context_processors.pynu �[��� from django.contrib.messages.api import get_messages from django.contrib.messages.constants import DEFAULT_LEVELS def messages(request): """ Return a lazy 'messages' context variable as well as 'DEFAULT_MESSAGE_LEVELS'. """ return { "messages": get_messages(request), "DEFAULT_MESSAGE_LEVELS": DEFAULT_LEVELS, } PK w��Z��ߣj j __init__.pynu �[��� from django.contrib.messages.api import * # NOQA from django.contrib.messages.constants import * # NOQA PK w��Zu��I utils.pynu �[��� from django.conf import settings from django.contrib.messages import constants def get_level_tags(): """ Return the message level tags. """ return { **constants.DEFAULT_TAGS, **getattr(settings, "MESSAGE_TAGS", {}), } PK w��Z+��� views.pynu �[��� PK w��Zk��8 8 D constants.pynu �[��� PK w��Z2 �� $ � __pycache__/__init__.cpython-310.pycnu �[��� PK w��Z���(@ @ . __pycache__/context_processors.cpython-310.pycnu �[��� PK w��Z��(�� � % � __pycache__/constants.cpython-310.pycnu �[��� PK w��Z���_] ] � __pycache__/api.cpython-310.pycnu �[��� PK w��ZI�3'� � ! \ __pycache__/utils.cpython-310.pycnu �[��� PK w��Z���i � __pycache__/apps.cpython-310.pycnu �[��� PK w��Z��9�� � & � __pycache__/middleware.cpython-310.pycnu �[��� PK w��Z깨� � ! %! __pycache__/views.cpython-310.pycnu �[��� PK w��Z���� � &% middleware.pynu �[��� PK w��ZZ��~� � =) api.pynu �[��� PK w��Z �� � %6 storage/base.pynu �[��� PK w��Z>�O� * M storage/__pycache__/cookie.cpython-310.pycnu �[��� PK w��Z��� , f storage/__pycache__/fallback.cpython-310.pycnu �[��� PK w��Z˝�L� � , �n storage/__pycache__/__init__.cpython-310.pycnu �[��� PK w��Z65) � � + �q storage/__pycache__/session.cpython-310.pycnu �[��� PK w��Z��5# # ( �z storage/__pycache__/base.cpython-310.pycnu �[��� PK w��ZTa�� � J� storage/cookie.pynu �[��� PK w��ZkW�Q- - S� storage/fallback.pynu �[��� PK w��ZMlR�� � ö storage/session.pynu �[��� PK w��Z��X� � � storage/__init__.pynu �[��� PK w��Ze�I� �� apps.pynu �[��� PK w��Zr�c�b b � context_processors.pynu �[��� PK w��Z��ߣj j �� __init__.pynu �[��� PK w��Zu��I U� utils.pynu �[��� PK ! ��
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings