|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /usr/lib/python2.7/site-packages/werkzeug/ |
Upload File : |
�
./�_c @ s� d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l m Z d d l m Z d d l m
Z
d d l m Z d d l m Z d d l m
Z
d d
l m Z d d l m Z d d l m Z d d
l m Z d d l m Z y0 d d l Z d d l m Z d d l m Z Wn= e k
rad d l Z d d l m Z d d l m Z n Xy d d l Z Wn0 e k
r�d e f d � � YZ e � Z n Xy d d l Z Wn e k
r�e! Z n Xe j" Z" e# e d � Z$ e$ r�e j% Z% n d e f d � � YZ% y
e j& Z' Wn e( k
r5e! Z' n Xd Z) e oOe# e d � Z* e
rde j+ Z, n e- Z, d e j. f d � � YZ/ d e e f d � � YZ0 e0 Z1 e! d � Z2 e! e! d � Z3 d � Z4 e! e! d � Z5 d e f d! � � YZ6 e! d" � Z7 d# � Z8 d$ � Z9 d% e e f d& � � YZ: d' e" e: f d( � � YZ; d) e% e: f d* � � YZ< e! e! e! e= d e! e= e! e! d+ � Z> d, � Z? e= e= e@ e! d d- e= d e! e! e= e! d. � ZA d/ � ZB d0 � ZC eD d1 k r�eC � n d S(2 s7
werkzeug.serving
~~~~~~~~~~~~~~~~
There are many ways to serve a WSGI application. While you're developing
it you usually don't want a full blown webserver like Apache but a simple
standalone one. From Python 2.5 onwards there is the `wsgiref`_ server in
the standard library. If you're using older versions of Python you can
download the package from the cheeseshop.
However there are some caveats. Sourcecode won't reload itself when
changed and each time you kill the server using ``^C`` you get an
`KeyboardInterrupt` error. While the latter is easy to solve the first
one can be a pain in the ass in some situations.
The easiest way is creating a small ``start-myproject.py`` that runs the
application::
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from myproject import make_app
from werkzeug.serving import run_simple
app = make_app(...)
run_simple('localhost', 8080, app, use_reloader=True)
You can also pass it a `extra_files` keyword argument with a list of
additional files (like configuration files) you want to observe.
For bigger applications you should consider using `click`
(http://click.pocoo.org) instead of a simple start file.
:copyright: 2007 Pallets
:license: BSD-3-Clause
i����N( t datetime( t timedeltai ( t PY2( t reraise( t WIN( t wsgi_encoding_dance( t _log( t InternalServerError( t
uri_to_iri( t url_parse( t url_unquote( t BaseHTTPRequestHandler( t
HTTPServert _SslDummyc B s e Z d � Z RS( c C s t d � � d S( Ns SSL support unavailable( t RuntimeError( t selft name( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt __getattr__F s ( t __name__t
__module__R ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR
E s t forkt ForkingMixInc B s e Z RS( ( R R ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR X s i� t fromfdt DechunkedInputc B s2 e Z d Z d � Z d � Z d � Z d � Z RS( s8 An input stream that handles Transfer-Encoding 'chunked'c C s | | _ t | _ d | _ d S( Ni ( t _rfilet Falset _donet _len( R t rfile( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt __init__q s c C s t S( N( t True( R ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt readablev s c C sp y1 | j j � j d � } t | j � d � } Wn t k
rP t d � � n X| d k rl t d � � n | S( Nt latin1i s Invalid chunk headeri s! Negative chunk length not allowed( R t readlinet decodet intt stript
ValueErrort IOError( R t lineR ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt read_chunk_leny s
c C s d } x� | j r | t | � k r | j d k rF | j � | _ n | j d k ra t | _ n | j d k r� t t | � | j � } | j j | � | | | | +| j | 8_ | | 7} n | j d k r | j j � } | d k r� t d � � q� q q W| S( Ni s
s
s
s! Missing chunk terminating newline( s
s
s
(
R t lenR R( R t minR t readR! R& ( R t bufR+ t nt
terminator( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt readinto� s
( R R t __doc__R R R( R/ ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR n s
t WSGIRequestHandlerc B s� e Z d Z e d � � Z d � Z d � Z d � Z d � Z d d � Z
d � Z d d � Z d � Z
d
� Z d � Z d d d
� Z d � Z d � Z d � Z d � Z RS( s3 A request handler that implements WSGI dispatching.c C s d d l m } d | S( Ni ( t __version__s Werkzeug/( t R2 ( R R2 ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt server_version� s c s t � j � } � f d � } � j j d k r6 d n d } � j sQ d � _ n t � j t � rx � j d f � _ n | j r� | j r� d | j | j f } n | j } t
| � } i d, d 6| d 6� j d
6t j
d 6� j j d 6� j j d
6t d 6| d 6� j d 6� j d 6d d 6t | � d 6t | j � d 6t � j � d 6t � j � d 6� j � d 6� j � d 6� j j d d 6t � j j d � d 6� j d 6} x� � j � D]~ \ } } | j � j d d � } | j d d � } | d- k r.d" | } | | k r.d# j | | | � } q.n | | | <q�W| j d$ d � j � j � d% k r�t | d& <t! | d
� | d
<n | j r�| j r�| j | d' <n y; � j" j# d( t � } | d k r�t$ j% | � | d) <n Wn4 t& k
r� j j' d* d+ � n t( k
rn X| S(. Nc s t � j _ d S( N( R t servert shutdown_signal( ( R ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt shutdown_server� s t httpt httpss <local>i s /%s%si s wsgi.versions wsgi.url_schemes
wsgi.inputs wsgi.errorss wsgi.multithreads wsgi.multiprocesss
wsgi.run_onces werkzeug.server.shutdownt SERVER_SOFTWAREt REQUEST_METHODR3 t SCRIPT_NAMEt PATH_INFOt QUERY_STRINGt REQUEST_URIt RAW_URIt REMOTE_ADDRt REMOTE_PORTt SERVER_NAMEt SERVER_PORTt SERVER_PROTOCOLt -t _s
t CONTENT_TYPEt CONTENT_LENGTHt HTTP_s {},{}t HTTP_TRANSFER_ENCODINGt chunkeds wsgi.input_terminatedt HTTP_HOSTt binary_formt SSL_CLIENT_CERTt errors& Cannot fetch SSL peer certificate info( i i ( s CONTENT_TYPEs CONTENT_LENGTH() R t pathR5 t ssl_contextt Nonet client_addresst
isinstancet strt schemet netlocR
R t syst stderrt multithreadt multiprocessR R4 t commandR t queryt address_stringt port_integert server_addresst request_versiont get_header_itemst uppert replacet formatt getR$ t lowerR R t
connectiont getpeercertt sslt DER_cert_to_PEM_certR% t logt AttributeError( R t request_urlR7 t
url_schemet path_infot environt keyt valuet peer_cert( ( R s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt make_environ� sl
$
c st � j j d d � j � j � d k r: � j j d � n � j � � _ � g � g � � � � � f d � � d � � � f d � � � � � � f d � } y | � j j
� Wn� t t j
f k
r� } � j | � � n� t k
ro� j j r� n d d l m } | d
t � } y � s1� 2n | t � � Wn t k
rRn X� j j d d | j � n Xd S(
Nt ExpectR3 s 100-continues HTTP/1.1 100 Continue
c s� � s t d � � � sr� \ } } � (y | j d d � \ } } Wn t k
re | d } } n Xt | � } � j | | � t � } x= | D]5 \ } } � j | | � | j � } | j | � q� Wd | k p� � d d k p� | d k p� | d k st
� _ � j d
d � n d | k r@� j d
� j � � n d | k re� j d � j
� � n � j � n t | t � s�t d � � | r�� j j | � n � j j � d S( Ns write() before start_responsei R3 s content-lengthR; t HEADi� i� i0 t
Connectiont closeR5 t Servert datet Dates applications must write bytes( i� i0 ( t AssertionErrort splitRS R% R# t
send_responset sett send_headerRh t addR t close_connectiont version_stringt date_time_stringt end_headersRU t bytest wfilet writet flush( t datat statust response_headerst codet msgt header_keysRs Rt ( Rr t headers_sentt headers_setR ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� s:
c sP | r* z � r t | � n Wd d } Xn � r? t d � � n | | g � (� S( Ns Headers already set( R RS R~ ( R� R� t exc_info( R� R� R� ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt start_response+ s
c se | � � � } z2 x | D] } � | � q W� s@ � d � n Wd t | d � r` | j � n Xd S( NR3 Rz ( t hasattrRz ( t appt application_iterR� ( Rr R� R� R� ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt execute7 s
i ( t get_current_tracebackt ignore_system_exceptionsRP s Error on request:
%s( t headersRg Rh R$ R� R� Rv Rr RS R5 R� t _ConnectionErrort sockett timeoutt connection_droppedt Exceptiont passthrough_errorst
debug.tbtoolsR� R R Rm t plaintext( R R� t eR� t traceback( ( Rr R� R� R R� R� s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt run_wsgi s0 '#
c C s� y t j | � Wn` t t j f k
r< } | j | � n8 t k
rs } | j j d k sj t
| � rt � qt n X| j j r� | j � n d S( s/ Handles a request ignoring dropped connections.N(
R t handleR� R� R� R� R� R5 RR RS t is_ssl_errorR6 t initiate_shutdown( R R� ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� V s
c C sS t t d t j � } t � r7 t j t j � | � n t | j _ t
| j _ d S( sp A horrible, horrible way to kill the server for Python 2.6 and
later. It's the best we can do.
t SIGKILLN( t getattrt signalt SIGTERMt is_running_from_reloadert ost killt getpidR R5 t _BaseServer__shutdown_requestR t _BaseServer__serving( R t sig( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� b s
c C s d S( s` Called if the connection was closed by the client. By default
nothing happens.
N( ( R RP Rr ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� p s c C sA | j j � | _ | j s' d | _ n | j � r= | j � Sd S( s Handle a single HTTP request.i N( R R! t raw_requestlineR� t
parse_requestR� ( R ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt handle_one_requestu s
c C s� | j | � | d k rB | | j k r9 | j | d p< d } n | j d k r� d | j | | f } | j j | j d � � n d S( s3 Send the response header and log the response code.i R3 s HTTP/0.9s
%s %d %s
t asciiN( t log_requestRS t responsesRb t protocol_versionR� R� t encode( R R� t messaget hdr( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� } s
)c C s t j | � j � S( N( R R� R$ ( R ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� � s c C sR t | d d � r | j d S| j s* d St | j t � rC | j S| j d Sd S( NRr RA s <local>i ( R� RS Rr RT RU RV ( R ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR_ � s c C s | j d S( Ni ( RT ( R ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR` � s RF c C sx y, t | j � } d | j | | j f } Wn t k
rH | j } n Xt | � } t r[t j } | d d k r� | | d t �} q[| d d k r� | | d d �} q[| d k r� | | d d �} q[| d d
k r� | | d d �} q[| d k r| | d d
�} q[| d d k r@| | d d d t �} q[| | d d d t �} n | j
d d | | | � d S( Ns %s %s %si t 1t boldt 2t fgt whitet 304t cyant 3t greent 404t yellowt 4t redt magentat infos
"%s" %s %s( R RQ R] Rb Rn t requestlineRV t clickt styleR Rm ( R R� t sizeRQ R� t color( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� � s,
c G s | j d | � d S( NRP ( Rm ( R t args( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt log_error� s c G s | j d | | � d S( NR� ( Rm ( R Rf R� ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt log_message� s c G s. t | d | j � | j � | | f � d S( Ns %s - - [%s] %s
( R R_ t log_date_time_string( R t typeR� R� ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyRm � s c C s� t r� g } x� | j j D]� } y# | d d !j d d � \ } } WnI t k
r� | d d k r� | r� | j � \ } } | | } q� � n X| j | | j � f � q Wn | j j � } | S( sV
Get an iterable list of key/value pairs representing headers.
This function provides Python 2/3 compatibility as related to the
parsing of request headers. Python 2.7 is not compliant with
RFC 3875 Section 4.1.18 which requires multiple values for headers
to be provided or RFC 2616 which allows for folding of multi-line
headers. This function will return a matching list regardless
of Python version. It can be removed once Python 2.7 support
is dropped.
:return: List of tuples containing header hey/value pairs
i i����t :i s t ( s R� ( R R� R R% t popt appendt lstript items( R R� t headerRs Rt ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyRc � s #
N( R R R0 t propertyR4 Rv R� R� R� RS R� R� R� R� R_ R` R� R� R� Rm Rc ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR1 � s" S V
c C s� yT d d l m } d d l m } d d l m } d d l m } d d l m } Wn t
k
rs t d � � n X| j d d d
d d | � � } | d k r� d
} n | j | j | j d � | j | j | � g � } | j � j | � j | � j | j � � j | j � � j t j � � j t j � t d d � � j | j | j g � d t �j | j! | j" d
� g � d t �j# | | j$ � | � � } | | f S( Ni����( t x509( t NameOID( t default_backend( t hashes( t rsas< Using ad-hoc certificates requires the cryptography library.t public_exponenti t key_sizei t backendu *u Dummy Certificatet daysim t critical(% t cryptographyR� t cryptography.x509.oidR� t cryptography.hazmat.backendsR� t cryptography.hazmat.primitivesR� t) cryptography.hazmat.primitives.asymmetricR� t ImportErrort TypeErrort generate_private_keyRS t Namet
NameAttributet ORGANIZATION_NAMEt COMMON_NAMEt CertificateBuildert subject_namet issuer_namet
public_keyt
serial_numbert random_serial_numbert not_valid_beforet dtt utcnowt not_valid_afterR t
add_extensiont ExtendedKeyUsaget OID_SERVER_AUTHR t SubjectAlternativeNamet DNSNamet signt SHA256( t cnR� R� R� R� R� t pkeyt subjectt cert( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt generate_adhoc_ssl_pair� s4
$c
C s� | d k r d | | f } n t d | � \ } } d d l m } | d } | d } t | d � �# } | j | j | j j � � Wd QXt | d � �> } | j | j d | j j d
| j
j d | j � � � Wd QX| | f S( s� Creates an SSL key for development. This should be used instead of
the ``'adhoc'`` key which generates a new cert on each server start.
It accepts a path for where it should store the key and cert and
either a host or CN. If a host is given it will use the CN
``*.host/CN=host``.
For more information see :func:`run_simple`.
.. versionadded:: 0.9
:param base_path: the path to the certificate and key. The extension
``.crt`` is added for the certificate, ``.key`` is
added for the key.
:param host: the name of the host. This can be used as an alternative
for the `cn`.
:param cn: the `CN` to use.
u
*.%s/CN=%sR i����( t
serializations .crts .keyt wbNt encodingRf t encryption_algorithm(
RS R R� R
t openR� t public_bytest Encodingt PEMt
private_bytest
PrivateFormatt TraditionalOpenSSLt NoEncryption( t base_patht hostR R R R
t cert_filet pkey_filet f( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt make_ssl_devcert! s
" c
C s d d l } d d l } t � \ } } d d l m } | j � \ } } | j � \ } } | j t j | � | j t j | � t j | | j
| j j � � t j | | j
d | j j d | j j d | j � � � t j | � t j | � t | | � } | S( s: Generates an adhoc SSL context for the development server.i����N( R
R Rf R ( t tempfilet atexitR R� R
t mkstempt registerR� t removeR� R R R R R R R Rz t load_ssl_context(
R R R R R
t cert_handleR t pkey_handleR t ctx( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt generate_adhoc_ssl_contextK s&
c C sY | d k r9 y
t j } Wq9 t k
r5 t j } q9 Xn t | � } | j | | � | S( s� Loads SSL context from cert/private key files and optional protocol.
Many parameters are directly taken from the API of
:py:class:`ssl.SSLContext`.
:param cert_file: Path of the certificate to use.
:param pkey_file: Path of the private key to use. If not given, the key
will be obtained from the certificate file.
:param protocol: One of the ``PROTOCOL_*`` constants in the stdlib ``ssl``
module. Defaults to ``PROTOCOL_SSLv23``.
N( RS Rk t PROTOCOL_TLS_SERVERRn t PROTOCOL_SSLv23t _SSLContextt load_cert_chain( R R t protocolR' ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR$ i s
R+ c B s/ e Z d Z d � Z d d d � Z d � Z RS( su A dummy class with a small subset of Python3's ``ssl.SSLContext``, only
intended to be used with and by Werkzeug.c C s( | | _ d | _ d | _ d | _ d S( N( t _protocolRS t _certfilet _keyfilet _password( R R- ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR � s c C s% | | _ | p | | _ | | _ d S( N( R/ R0 R1 ( R t certfilet keyfilet password( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR, � s c K s+ t j | d | j d | j d | j | �S( NR3 R2 t ssl_version( Rk t wrap_socketR0 R/ R. ( R t sockt kwargs( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR6 � s N( R R R0 R RS R, R6 ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR+ s c C s/ | d k r t j � d } n t | t j � S( s? Checks if the given error (or the current one) is an SSL error.i N( RS RY R� RU Rk t SSLError( RP ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� � s c C s? | j d � r t j Sd | k r8 t t d � r8 t j St j S( sU Return ``AF_INET4``, ``AF_INET6``, or ``AF_UNIX`` depending on
the host and port.s unix://R� t AF_INET6( t
startswithR� t AF_UNIXR� R: t AF_INET( R t port( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt select_address_family� s
c C so | t k r | j d d � d Sy% t j | | | t j t j � } Wn t j k
rb | | f SX| d d S( sV Return a fully qualified socket address that can be passed to
:func:`socket.bind`.s ://i i i ( t af_unixR R� t getaddrinfot SOCK_STREAMt IPPROTO_TCPt gaierror( R R> t familyt res( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt get_sockaddr� s t BaseWSGIServerc B sY e Z d Z e Z e Z e Z d e d d d � Z d � Z
d � Z d � Z d � Z
RS( s3 Simple single-threaded, single-process WSGI server.c C s� | d k r t } n t | | � | _ | d k rW t j | | j t j � } d } n t | t | � | j � } | j t k r� t
j j | � r� t
j
| � n t j | | | � | | _ | | _ t | _ | | _ | j j � d | _ | d k r'| j j � | | _ | j j � | _ n | d k r�t | t � rQt | � } n | d k rit � } n | j }
t r�t |
t j � r�t j |
j |
j |
j |
� }
n | j! |
d t" �| _ | | _# n d | _# d S( Ni i t adhoct server_side($ RS R1 R? t address_familyR� R RB RG R# R@ R� RQ t existst unlinkR R R� R� R R6 R t getsocknameR> Rz Ra RU t tupleR$ R( R RE R� t protoR6 R RR ( R R R> R� t handlerR� RR t fdt real_sockRa R7 ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR � s<
!
$ c G s t | | | � d S( N( R ( R R� R� R� ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyRm s c C sD t | _ z) y t j | � Wn t k
r0 n XWd | j � Xd S( N( R R6 R t
serve_forevert KeyboardInterruptt server_close( R ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyRT s
c C s? | j r � n t t j � d t � r, d St j | | | � S( Ni ( R� RU RY R� R� R t handle_error( R t requestRT ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyRW s
c C s | j j � \ } } | | f S( N( R� t accept( R t conR� ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt get_request s N( R R R0 R R[ R\ t LISTEN_QUEUEt request_queue_sizeRS R Rm RT RW R[ ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyRH � s / t ThreadedWSGIServerc B s e Z d Z e Z e Z RS( s" A WSGI server that does threading.( R R R0 R R[ t daemon_threads( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR^ s t ForkingWSGIServerc B s, e Z d Z e Z d d e d d d � Z RS( s A WSGI server that does forking.i( c C sD t s t d � � n t j | | | | | | | | � | | _ d S( Ns' Your platform does not support forking.( t can_forkR% RH R t max_children( R R R> R� t processesRQ R� RR RR ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR + s
N( R R R0 R R\ RS R R ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR` % s c C s� | r! | d k r! t d � � nr | rF t | | | | | | d | �S| d k rt t | | | | | | | d | �St | | | | | | d | �Sd S( st Create a new server instance that is either threaded, or forks
or just processes one request after another.
i s5 cannot have a multithreaded and multi process server.RR N( R% R^ R` RH ( R R> R� t threadedRc t request_handlerR� RR RR ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt make_server> s" c C s t j j d � d k S( sw Checks if the application is running from within the Werkzeug
reloader subprocess.
.. versionadded:: 0.10
t WERKZEUG_RUN_MAINt true( R� Rr Rg ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyR� c s t autoc s� t � t � s t d � � n | rF d d l m } | � | � � n | rn d d l m } | � | � � n � � f d � � � � � � � � � � � f d � } | r�t � s�� d k r� t r� t d � � n t
� � � } t � � | � } t j | t j
� } | j t j t j d � | j | � t | d � rS| j t � n t r�t | j � � t j d
<| j t � � | � q�| j � | t k r�t d d | � t j | � q�n d d
l m } | | | | | � n | � d S( s�
Start a WSGI application. Optional features include a reloader,
multithreading and fork support.
This function has a command-line interface too::
python -m werkzeug.serving --help
.. versionadded:: 0.5
`static_files` was added to simplify serving of static files as well
as `passthrough_errors`.
.. versionadded:: 0.6
support for SSL was added.
.. versionadded:: 0.8
Added support for automatically loading a SSL context from certificate
file and private key.
.. versionadded:: 0.9
Added command-line interface.
.. versionadded:: 0.10
Improved the reloader and added support for changing the backend
through the `reloader_type` parameter. See :ref:`reloader`
for more information.
.. versionchanged:: 0.15
Bind to a Unix socket by passing a path that starts with
``unix://`` as the ``hostname``.
:param hostname: The host to bind to, for example ``'localhost'``.
If the value is a path that starts with ``unix://`` it will bind
to a Unix socket instead of a TCP socket..
:param port: The port for the server. eg: ``8080``
:param application: the WSGI application to execute
:param use_reloader: should the server automatically restart the python
process if modules were changed?
:param use_debugger: should the werkzeug debugging system be used?
:param use_evalex: should the exception evaluation feature be enabled?
:param extra_files: a list of files the reloader should watch
additionally to the modules. For example configuration
files.
:param reloader_interval: the interval for the reloader in seconds.
:param reloader_type: the type of reloader to use. The default is
auto detection. Valid values are ``'stat'`` and
``'watchdog'``. See :ref:`reloader` for more
information.
:param threaded: should the process handle each request in a separate
thread?
:param processes: if greater than 1 then handle each request in a new process
up to this maximum number of concurrent processes.
:param request_handler: optional parameter that can be used to replace
the default one. You can use this to replace it
with a different
:class:`~BaseHTTPServer.BaseHTTPRequestHandler`
subclass.
:param static_files: a list or dict of paths for static files. This works
exactly like :class:`SharedDataMiddleware`, it's actually
just wrapping the application in that middleware before
serving.
:param passthrough_errors: set this to `True` to disable the error catching.
This means that the server will die on errors but
it can be useful to hook debuggers in (pdb etc.)
:param ssl_context: an SSL context for the connection. Either an
:class:`ssl.SSLContext`, a tuple in the form
``(cert_file, pkey_file)``, the string ``'adhoc'`` if
the server should automatically create one, or ``None``
to disable SSL (which is the default).
s port must be an integeri ( t DebuggedApplication( t SharedDataMiddlewarec s� � d
k r � n d } d } | j t k rC t d d | | � nT d | k r\ d | } n | j � d } t d d
� d k r� d n d | | | � d S( NR3 t *t localhosts (Press CTRL+C to quit)R� s * Running on %s %sR� s [%s]i s * Running on %s://%s:%d/ %sR8 R9 ( R3 Rl ( RE R@ R RN RS ( R7 t display_hostnamet quit_msgR> ( t hostnameRR ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt log_startup� s
c s� y t t j d � } Wn t t f k
r6 d } n Xt � � � � � � � � d | �} | d k rz � | j � n | j � d S( Nt WERKZEUG_SERVER_FDRR ( R# R� Rr t LookupErrorR% RS Rf R� RT ( RR t srv( t applicationRp Rq R� R> Rc Re RR Rd ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt inner� s"
i ss Cannot bind to a random port with enabled reloader if the Python interpreter does not support socket opening by fd.t set_inheritableRr R� s Unlinking %s( t run_with_reloaderN(! RU R# R� t debugRj t middleware.shared_dataRk R� t can_open_by_fdR% R? RG R� RB t
setsockoptt
SOL_SOCKETt SO_REUSEADDRt bindR� Rw R RV t filenoR� Rr t listenR\ Rz R@ R RM t _reloaderRx ( Rp R> Ru t use_reloadert use_debuggert
use_evalext extra_filest reloader_intervalt
reloader_typeRd Rc Re t static_filesR� RR Rj Rk Rv RK Ra t sRx ( ( Ru Rp Rq R� R> Rc Re RR Rd s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt
run_simplel sB V'
c O s d d l m } | | | � S( Ni ( Rx ( R� Rx ( R� R8 Rx ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyRx s c
C s� d d l } d d l m } | j d d � } | j d d d d
d d �| j d
d d d d d d t d d �| j d d d d d d d t d d �| j � \ } } d \ } } | j r� | j j d � } | d } t
| � d k r� | d } q� n t
| � d k r1t j j
d � t j d � n | | d � } t d | pPd d t | p_d � d | d | j d | j � d S(! s: A simple command-line interface for :py:func:`run_simple`.i����Ni ( t
import_stringt usages, Usage: %prog [options] app_module:app_objects -bs --bindt destt addresst helps+ The hostname:port the app should listen on.s -ds --debugR� t actiont
store_truet defaults Use Werkzeug's debugger.s -rs --reloadR� s( Reload Python process if modules change.R� i s1 No application supplied, or too much. See --help
Rp s 127.0.0.1R> i� Ru ( NN( t optparset utilsR� t OptionParsert
add_optionR t
parse_argsRS R� R R) RY t stdoutR� t exitR� R# R� R� ( R� R� t parsert optionsR� Rp R> R� R� ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt main' sN
t __main__(E R0 t ioR� R� R� RY R R� R t _compatR R R R t _internalR t
exceptionsR t urlsR R R
t socketservert http.serverR R R� t SocketServert BaseHTTPServerRk t objectR
R� RS t ThreadingMixInR� Ra R R< R@ Rn R\ R{ RP R� t ConnectionErrort RawIOBaseR R1 t BaseRequestHandlerR R R( R$ R+ R� R? RG RH R^ R` R Rf R� R R� Rx R� R ( ( ( s4 /tmp/pip-install-sTXtzD/Werkzeug/werkzeug/serving.pyt <module>% s�
5� S )* Y
� 5