o

weA*�@s�dZd
dl
Zd
dlmZ
d
dlZd
dlZd
dlmZ
d
dlm	Z	
d
dlm
Z

d
dlmZ
d
dl
mZ
d
d	lmZmZmZmZmZmZmZ
d
d
lmZ
d
dlZejr]d
dlmZ
d
dlmZ
d
edefdd�Z Gdd�de!�Z"e
j#Z$dS)aWSGI support for the Tornado web framework.

WSGI is the Python standard for web servers, and allows for interoperability
between Tornado and other Python web frameworks and servers.

This module provides WSGI support via the `WSGIContainer` class, which
makes it possible to run applications using other WSGI frameworks on
the Tornado HTTP server. The reverse is not supported; the Tornado
`.Application` and `.RequestHandler` classes are designed for use with
the Tornado `.HTTPServer` and cannot be used in a generic WSGI
container.

�N)
�BytesIO)
�dummy_executor)
�escape)
�httputil)
�IOLoop)
�
access_log)�List�Tuple�Optional�Callable�Any�Dict�Text)
�
TracebackType)
�Type)
�WSGIApplication�
s�returnc

Cst|t
�sJ�
|�d
�
S)N�latin1)�
isinstance�bytes�decode)
r�r�E/home/arjun/projects/env/lib/python3.10/site-packages/tornado/wsgi.py�to_wsgi_str6s


rc@s�eZ
dZd
Z	ddddeejjddfdd�Zd	e	j
ddfd
d�Zd	e	j
ddfdd
�Zd	e	j
de
eeffdd�Zded	e	j
ddfdd�ZdS)�
WSGIContainera�Makes a WSGI-compatible application runnable on Tornado's HTTP server.

    .. warning::

       WSGI is a *synchronous* interface, while Tornado's concurrency model
       is based on single-threaded *asynchronous* execution.  Many of Tornado's
       distinguishing features are not available in WSGI mode, including efficient
       long-polling and websockets. The primary purpose of `WSGIContainer` is
       to support both WSGI applications and native Tornado ``RequestHandlers`` in
       a single process. WSGI-only applications are likely to be better off
       with a dedicated WSGI server such as ``gunicorn`` or ``uwsgi``.

    Wrap a WSGI application in a `WSGIContainer` to make it implement the Tornado
    `.HTTPServer` ``request_callback`` interface.  The `WSGIContainer` object can
    then be passed to classes from the `tornado.routing` module,
    `tornado.web.FallbackHandler`, or to `.HTTPServer` directly.

    This class is intended to let other frameworks (Django, Flask, etc)
    run on the Tornado HTTP server and I/O loop.

    Realistic usage will be more complicated, but the simplest possible example uses a
    hand-written WSGI application with `.HTTPServer`::

        def simple_app(environ, start_response):
            status = "200 OK"
            response_headers = [("Content-type", "text/plain")]
            start_response(status, response_headers)
            return [b"Hello world!\n"]

        async def main():
            container = tornado.wsgi.WSGIContainer(simple_app)
            http_server = tornado.httpserver.HTTPServer(container)
            http_server.listen(8888)
            await asyncio.Event().wait()

        asyncio.run(main())

    The recommended pattern is to use the `tornado.routing` module to set up routing
    rules between your WSGI application and, typically, a `tornado.web.Application`.
    Alternatively, `tornado.web.Application` can be used as the top-level router
    and `tornado.web.FallbackHandler` can embed a `WSGIContainer` within it.

    If the ``executor`` argument is provided, the WSGI application will be executed
    on that executor. This must be an instance of `concurrent.futures.Executor`,
    typically a ``ThreadPoolExecutor`` (``ProcessPoolExecutor`` is not supported).
    If no ``executor`` is given, the application will run on the event loop thread in
    Tornado 6.3; this will change to use an internal thread pool by default in
    Tornado 7.0.

    .. warning::
       By default, the WSGI application is executed on the event loop's thread. This
       limits the server to one request at a time (per process), making it less scalable
       than most other WSGI servers. It is therefore highly recommended that you pass
       a ``ThreadPoolExecutor`` when constructing the `WSGIContainer`, after verifying
       that your application is thread-safe. The default will change to use a
       ``ThreadPoolExecutor`` in Tornado 7.0.

    .. versionadded:: 6.3
       The ``executor`` parameter.

    .. deprecated:: 6.3
       The default behavior of running the WSGI application on the event loop thread
       is deprecated and will change in Tornado 7.0 to use a thread pool by default.
    N�wsgi_application�WSGIAppType�executorrcCs"|
|_|durt
|_dS||_dS�
N)rrr)�selfrrrrr�__init__}s
zWSGIContainer.__init__�requestcCst�
��|j|
�
dSr)r�current�spawn_callback�handle_request)r r"rrr�__call__�s
zWSGIContainer.__call__c�s�
i�
g�	dd
tdt
tttfdttdttttfdttg
tff�
�fdd�
}t	�
�}|�|j|j
|�|
�
|�IdH}z0t|�
�dttf�f
dd	�}	|�|j|�IdH}|duran��|�

qRWt|d�rq|��
nt|d�r||��
wwd���
}�
s�td
�
�
�
d
�dd�\}}	t|�
}
�
d}tdd�|D�
�
}t�|�
}|
dkr�d|v
r�|�dtt|�
�
f�

d|v
r�|�d�

d|v
r�|�ddtjf�

t�d|
|	�}
t��}|D]
\}}|� ||�
q�|
j!du
s�J�
|
j!j"|
||d�
|
j!�#�
|�$|
|
�
dS)N�status�headers�exc_infozOptional[Type[BaseException]]rcs|�d
<|
�d<�
jS)Nr'r()
�append)r'r(r))�data�responserr�start_response�s

z4WSGIContainer.handle_request.<locals>.start_responsecs zt��
WSt
y


YdSwr)�next�
StopIterationr)
�app_response_iterrr�
next_chunk�s




�z0WSGIContainer.handle_request.<locals>.next_chunkT�close�z$WSGI app did not call start_response�
 �
c
ss�|]	\}
}|
��V
qdSr)
�lower)�.0�
k�
vrrr�	<genexpr>�s�z/WSGIContainer.handle_request.<locals>.<genexpr>i0
zcontent-length�Content-Lengthzcontent-type)�Content-Typeztext/html; charset=UTF-8�server�ServerzTornadoServer/%szHTTP/1.1)
�chunkr)%�strrr	r
�
BaseExceptionrrrrrr#�run_in_executorrr�environ�iterr*�hasattrr2�join�	Exception�split�int�setr�utf8�len�tornado�versionr�ResponseStartLine�HTTPHeaders�add�
connection�
write_headers�finish�_log)r r"r-�loop�app_responser1r?�body�status_code_str�reason�status_coder(�
header_set�
start_line�
header_obj�key�valuer)r0r+r,rr%�s��

�
��



����
�





�





�

�
�

�























zWSGIContainer.handle_requestcCs
|
j�
d
�
}t|�
dkr|d}t|d�
}n|
j}|
jdkr!dn
d}|
jdttj|
j	d	d
d��
|
j
|
j|t|�
|
j
d|
jtt�|
j�
�
tj|jtu
d
d
d�}d|
jvr\|
j�d�
|d<d|
jvri|
j�d�
|d<|
j��D]\}}||d|�dd���<qn|S)z�Converts a `tornado.httputil.HTTPServerRequest` to a WSGI environment.

        .. versionchanged:: 6.3
           No longer a static method.
        �
:�r
r5�httpsi�
�P�NF)�encoding�plus)r5r
T)�REQUEST_METHOD�SCRIPT_NAME�	PATH_INFO�QUERY_STRING�REMOTE_ADDR�SERVER_NAME�SERVER_PORT�SERVER_PROTOCOLzwsgi.versionzwsgi.url_schemez
wsgi.inputzwsgi.errorszwsgi.multithreadzwsgi.multiprocessz
wsgi.run_oncer<�CONTENT_TYPEr;�CONTENT_LENGTH�HTTP_�
-�
_)�hostrHrLrI�protocol�methodrr�url_unescape�path�query�	remote_ipr@rNrrKrX�sys�stderrrrr(�pop�items�replace�upper)r r"�hostportru�portrCr_r`rrrrC�s>






�










�







zWSGIContainer.environr[cCs~|
d
krtj
}n|
dkrtj}ntj}d|��}|jdu
s J�
|jdu
s'J�
|jd|jd|jd}|d|
||�
dS)Ni�
i�
g@�@r4z (�
)z%d %s %.2fms)r�info�warning�error�request_timerw�urir{)r r[r"�
log_methodr��summaryrrrrU�s*







������zWSGIContainer._logr)�__name__�
__module__�__qualname__�__doc__r
�
concurrent�futures�Executorr!r�HTTPServerRequestr&r%r
rrrCrIrUrrrrr;s
D��
�
�G(r)%r��concurrent.futuresr��iorrMr|�tornado.concurrentrrr�tornado.ioloopr�tornado.logr�typingrr	r
rrr
r�typesr�
TYPE_CHECKINGr�_typeshed.wsgirrrr@r�objectrr��HTTPRequestrrrr�<module>
s(






$




R