File: //opt/saltstack/salt/lib/python3.10/site-packages/cherrypy/__pycache__/__init__.cpython-310.pyc
o
;j�, � @ s d Z zddlmZ W n
ey ddlZY nw ddlmZ ddlm Z m
Z
m Z m Z m
Z
ddlmZ ddlmZmZ ddlmZmZmZ dd lmZmZmZm Z m Z ddl m m Z! dd
lm"Z" dd lm#Z$ dd lm%Z% zdd
l%m&Z& e&�'� Z(e&�)e(�e(_*[&W n ey� e%j+Z(Y nw ddlm,Z, dZ-e.d� e.d� e�/� Z0ze�1d�Z2W n e3y� dZ2Y nw e4� e(j5d< e4� e(j5d< e%j6�7e(�e(_8e(j8�9� e%j6�:e(�e(_;e(j;�9� e%j6�<e(�e(_=G dd� de>�Z?e?e(�e(_@e�A� ZBeB�9� d1dd�ZCG dd � d e�ZDeD� ZEG d d � d e>�ZFeFd �ZGeFd �ZHG d!d"� d"e�ZIeI� ZJd2d#d$�ZKz
ddlLZMeMjNeM_OeKeM_NW n
e�y; Y nw G d%d&� d&e jP�ZQeQ� ZRd'eR_SdeR_TdeR_Ue(�9d(�d)d*� �ZVe �W� ZXZYd'd'd'd'd+�eX_Zd,d-� eXj[d(< d.d-� eXj[d/< eX�\� e,�]� Z^e(�9d0e^� dS )3a� CherryPy is a pythonic, object-oriented HTTP framework.
CherryPy consists of not one, but four separate API layers.
The APPLICATION LAYER is the simplest. CherryPy applications are written as
a tree of classes and methods, where each branch in the tree corresponds to
a branch in the URL path. Each method is a 'page handler', which receives
GET and POST params as keyword arguments, and returns or yields the (HTML)
body of the response. The special method name 'index' is used for paths
that end in a slash, and the special method name 'default' is used to
handle multiple paths via a single handler. This layer also includes:
* the 'exposed' attribute (and cherrypy.expose)
* cherrypy.quickstart()
* _cp_config attributes
* cherrypy.tools (including cherrypy.session)
* cherrypy.url()
The ENVIRONMENT LAYER is used by developers at all levels. It provides
information about the current request and response, plus the application
and server environment, via a (default) set of top-level objects:
* cherrypy.request
* cherrypy.response
* cherrypy.engine
* cherrypy.server
* cherrypy.tree
* cherrypy.config
* cherrypy.thread_data
* cherrypy.log
* cherrypy.HTTPError, NotFound, and HTTPRedirect
* cherrypy.lib
The EXTENSION LAYER allows advanced users to construct and share their own
plugins. It consists of:
* Hook API
* Tool API
* Toolbox API
* Dispatch API
* Config Namespace API
Finally, there is the CORE LAYER, which uses the core API's to construct
the default components which are available at higher layers. You can think
of the default components as the 'reference implementation' for CherryPy.
Megaframeworks (and advanced users) may replace the default components
with customized or extended components. The core API's are:
* Application API
* Engine API
* Request API
* Server API
* WSGI API
These API's are described in the `CherryPy specification
<https://github.com/cherrypy/cherrypy/wiki/CherryPySpec>`_.
� N)�local� )� HTTPError� HTTPRedirect�InternalRedirect�NotFound�CherryPyException)� _cpdispatch)�default_toolbox�Tool)�expose�popargs�url)�
_cprequest� _cpserver�_cptree�
_cplogging� _cpconfig)� Application)�_cpwsgi)�process)�win32)�
_cpchecker)r r r r r �dispatch�toolsr r �wsgir �tree�engine�
quickstart�serving�request�response� thread_data�logr r
r �configzcherrypy._cptoolszcherrypy._cprequestZcherrypy�unknownZbefore_requestZ
after_requestc @ � e Zd ZdZdd� Zdd� ZdS )�_HandleSignalsPluginz_Handle signals from other processes.
Based on the configured platform handlers above.
c C �
|| _ d S �N)�bus)�selfr* � r, �E/opt/saltstack/salt/lib/python3.10/site-packages/cherrypy/__init__.py�__init__� �
z _HandleSignalsPlugin.__init__c C s8 t | jd�r | jj�� t | jd�r| jj�� dS dS )z'Add the handlers based on the platform.�signal_handler�console_control_handlerN)�hasattrr* r0 � subscriber1 �r+ r, r, r- r3 � s
�z _HandleSignalsPlugin.subscribeN)�__name__�
__module__� __qualname__�__doc__r. r3 r, r, r, r- r' � s r' � c C s: |rt �|� t�| ||� tj�� t�� t�� dS )an Mount the given root, start the builtin server (and engine), then block.
root: an instance of a "controller class" (a collection of page handler
methods) which represents the root of the application.
script_name: a string containing the "mount point" of the application.
This should start with a slash, and be the path portion of the URL
at which to mount the given root. For example, if root.index() will
handle requests to "http://www.example.com:8080/dept/app1/", then
the script_name argument would be "/dept/app1".
It MUST NOT end in a slash. If the script_name refers to the root
of the URI, it MUST be an empty string (not "/").
config: a file or dict containing application config. If this contains
a [global] section, those entries will be used in the global
(site-wide) config.
N) �_global_conf_alias�updater Zmountr �signalsr3 �start�block)�root� script_namer$ r, r, r- r � s
r c @ sH e Zd ZdZe�e�dd�e�dd��Z e� � Z
dd� Z dd� Z d S )
�_Servinga� An interface for registering request and response objects.
Rather than have a separate "thread local" object for the request
and the response, this class works as a single threadlocal container
for both objects (and any others which developers wish to define).
In this way, we can easily dump those objects when we stop/start a
new HTTP conversation, yet still refer to them as module-level
globals in a thread-safe way.
z 127.0.0.1�P iW c C s || _ || _d S r) )r r! )r+ r r! r, r, r- �load� s
z
_Serving.loadc C s | j �� dS )z Remove all attributes of self.N)�__dict__�clearr4 r, r, r- rE � s z_Serving.clearN)
r5 r6 r7 r8 r �Request� _httputil�Hostr ZResponser! rC rE r, r, r, r- rA � s
� rA c @ st e Zd ZddgZdd� Zdd� Zdd� Zd d
� Zed d � �Z d
d� Z
dd� Z dd� Z dd� Z
dd� Zdd� ZeZdS )�_ThreadLocalProxy� __attrname__rD c C r( r) �rJ )r+ �attrnamer, r, r- r. � r/ z_ThreadLocalProxy.__init__c C s t t| j�}t ||�S r) ��getattrr rJ �r+ �name�childr, r, r- � __getattr__� �
z _ThreadLocalProxy.__getattr__c C s6 |dv r
t �| ||� d S tt| j�}t|||� d S )NrK )�object� __setattr__rN r rJ �setattr)r+ rP �valuerQ r, r, r- rU � s z _ThreadLocalProxy.__setattr__c C s t t| j�}t||� d S r) )rN r rJ �delattrrO r, r, r- � __delattr__� s z _ThreadLocalProxy.__delattr__c C s( t t| j�}|jj�� }|�|j� |S r) )rN r rJ � __class__rD �copyr; )r+ rQ �dr, r, r- rD � s z_ThreadLocalProxy.__dict__c C s t t| j�}|| S r) rM �r+ �keyrQ r, r, r- � __getitem__� � z _ThreadLocalProxy.__getitem__c C s t t| j�}|||< d S r) rM )r+ r^ rW rQ r, r, r- � __setitem__� s z _ThreadLocalProxy.__setitem__c C s t t| j�}||= d S r) rM r] r, r, r- � __delitem__ rS z _ThreadLocalProxy.__delitem__c C s t t| j�}||v S r) rM r] r, r, r- � __contains__ r` z _ThreadLocalProxy.__contains__c C � t t| j�}t|�S r) )rN r rJ �len�r+ rQ r, r, r- �__len__
r` z_ThreadLocalProxy.__len__c C rd r) )rN r rJ �boolrf r, r, r- � __nonzero__ r` z _ThreadLocalProxy.__nonzero__N)r5 r6 r7 � __slots__r. rR rU rY �propertyrD r_ ra rb rc rg ri �__bool__r, r, r, r- rI � s
rI r r! c @ s e Zd ZdZdS )� _ThreadDataz%A container for thread-specific data.N)r5 r6 r7 r8 r, r, r, r- rm s rm c C s" t | t�r tt| j�} t�| |�S )zDGiven an object or a path to an object, get the object and its name.)�
isinstancerI rN r rJ �_pydoc�_builtin_resolve)�thingZ forceloadr, r, r- �_cherrypy_pydoc_resolve) s
rr c @ r& )�_GlobalLogManagera� A site-wide LogManager; routes to app.log or global log as appropriate.
This :class:`LogManager<cherrypy._cplogging.LogManager>` implements
cherrypy.log() and cherrypy.log.access(). If either
function is called during a request, the message will be sent to the
logger for the current Application. If they are called outside of a
request, the message will be sent to the site-wide logger.
c O s4 t td�rt tjd�rtjj}n| }|j|i |��S )z�Log the given message to the app.log or global log.
Log the given message to the app.log or global log as
appropriate.
�appr# )r2 r rt r# �error)r+ �args�kwargsr# r, r, r- �__call__B s
z_GlobalLogManager.__call__c C s. zt jj�� W S ty tj�| � Y S w )z�Log an access message to the app.log or global log.
Log the given message to the app.log or global log as
appropriate.
)r rt r# �access�AttributeErrorr �
LogManagerr4 r, r, r- ry P s
�z_GlobalLogManager.accessN)r5 r6 r7 r8 rx ry r, r, r, r- rs 8 s rs Tr# c C s t j| d|d� d S )NZENGINE)Zseverity)r# ru )�msg�levelr, r, r- �_buslogd s r~ )ztools.log_tracebacks.onztools.log_headers.onztools.trailing_slash.onztools.encode.onc C � t t| |�S r) )rV r# ��k�vr, r, r- �<lambda>r � r� c C r r) )rV �checkerr� r, r, r- r� s r� r� r= )Nr9 N)r )_r8 �importlib.metadata�metadataZimportlib_metadata� ImportError� threadingr �_localZ_cperrorr r r r r r9 r r Z_cptoolsr
r r Z_helperr r
r r r r r r Zcherrypy.lib.httputil�libZhttputilrG r r r r r ZWin32Busr ZConsoleCtrlHandlerr1 r* r �__all__�
__import__ZTreer �version� __version__� Exception�setZ listenersZpluginsZ AutoreloaderZ
autoreloadr3 Z
ThreadManagerZthread_managerZ
SignalHandlerr0 rT r' r< ZServerZserverr rA r rI r r! rm r" rr �pydocro �resolverp r{ rs r# ZscreenZ
error_fileZ access_filer~ ZConfigr$ r: �defaultsZ
namespaces�resetZCheckerr� r, r, r, r- �<module> s� : �
�
�
#;
�$
�