Name	Size	Mode	Actions
datastructures.cpython-36.pyc	107748	0644	editdlrm
exceptions.cpython-36.pyc	30639	0644	editdlrm
filesystem.cpython-36.pyc	2025	0644	editdlrm
formparser.cpython-36.pyc	13814	0644	editdlrm
http.cpython-36.pyc	37905	0644	editdlrm
local.cpython-36.pyc	22691	0644	editdlrm
routing.cpython-36.pyc	72931	0644	editdlrm
security.cpython-36.pyc	8040	0644	editdlrm
serving.cpython-36.pyc	30478	0644	editdlrm
test.cpython-36.pyc	38961	0644	editdlrm
testapp.cpython-36.pyc	9549	0644	editdlrm
urls.cpython-36.pyc	36414	0644	editdlrm
useragents.cpython-36.pyc	7417	0644	editdlrm
user_agent.cpython-36.pyc	1720	0644	editdlrm
utils.cpython-36.pyc	32960	0644	editdlrm
wsgi.cpython-36.pyc	30102	0644	editdlrm
_internal.cpython-36.pyc	18268	0644	editdlrm
_reloader.cpython-36.pyc	11899	0644	editdlrm
__init__.cpython-36.pyc	310	0644	editdlrm

3 _TBg���@s:dd
lZdd
l
Z
dd
lZddlmZ
ddlmZ
ddlmZ
ddl m Z
ddl mZ
ddl mZ
dd l mZ
dd lmZ
ddlmZ
ddlmZ
dd lmZ
ddlmZ
ddlmZ
ejr�ddlmZ
ddlmZ
ejdPdd�dd�ZdQdeeeejej e!e!d�dd�Z"dejej#e!eje$fd�dd�Z%dRdejej e!e!d�d d!�Z&deje$d�d"d#�Z'dSdeej(e)d%�d&d'�Z*de!d�d(d)�Z+dTde!e!e!d,�d-d.�Z,dUde!e!e!d,�d/d0�Z-dVde!e!eje!d,�d1d2�Z.dWde!e!eje!d,�d3d4�Z/dXej0e!dfej0e!efe!e!eeje!d6�d7d8�Z1Gd9d:�d:�Z2dYdej(e)e$ej e)d<�d=d>�Z3Gd?d@�d@�Z4GdAdB�dB�Z5ej0ej e)ej(e)feje$e$ej6e)dC�dDdE�Z7d[ej0ej e)ej(e)feje$e$eej6e)dH�dIdJ�Z8d]ej0ej e)ej(e)fe)eje$e$eej6e)dK�dLdM�Z9GdNdO�dOej:�Z;d
S)^�N)
�partial)
�update_wrapper)
�chain�
)
�_make_encode_wrapper)
� _to_bytes)
�_to_str)
�utils)
�host_is_trusted)
� _URLTuple)
� uri_to_iri)
�url_join)
� url_parse)
� url_quote)
�WSGIApplication)
�WSGIEnvironment.r)�
f�returnc

st�f
d
d���S)a
Marks a function as responder. Decorate a function with it and it will automatically call the return value as WSGI application. Example:: @responder def application(environ, start_response): return Response('Hello World!') c
s�|�|dd��S)N�������)
�
a)
rr�1/tmp/pip-build-0s3hx122/Werkzeug/werkzeug/wsgi.py�"szresponder..)
r)
rr)
rr� responders rFr)�environ� root_only�strip_querystring� host_only� trusted_hostsrcCsb|d
t||�d�}|sV|j
dd�|d<|
sV|j
dd�|d<|sV|j
dd�jd �
|d <tjf|�
S)aXRecreate the URL for a request from the parts in a WSGI environment. The URL is an IRI, not a URI, so it may contain Unicode characters. Use :func:`~werkzeug.urls.iri_to_uri` to convert it to ASCII. :param environ: The WSGI environment to get the URL parts from. :param root_only: Only build the root path, don't include the remaining path or query string. :param strip_querystring: Don't include the query string. :param host_only: Only build the scheme and host. :param trusted_hosts: A list of trusted host names to validate the host against. zwsgi.url_scheme)�scheme�host�SCRIPT_NAME�� root_path� PATH_INFO�path�QUERY_STRING�latin1Zquery_string)�get_host�get�encode� _sansio_utils�get_current_url)rrrrr�partsrrrr-%s



r-)rrc
CsP|jd
�
}
|
dkrdSyt
|jdd��
}Wnttfk rF


d}YnX|
|fS)NZSERVER_NAMEZSERVER_PORT)r*�int� TypeError� ValueError)r�name�portrrr�_get_serverKs 


 r4)rrrcCstj
|d
|jd�
t|�
|
�S)arReturn the host for the given WSGI environment. The ``Host`` header is preferred, then ``SERVER_NAME`` if it's not set. The returned host will only contain the port if it is different than the standard port for the protocol. Optionally, verify that the host is trusted using :func:`host_is_trusted` and raise a :exc:`~werkzeug.exceptions.SecurityError` if it is not. :param environ: A WSGI environment dict. :param trusted_hosts: A list of trusted host names. :return: Host, with port if necessary. :raise ~werkzeug.exceptions.SecurityError: If the host is not trusted. zwsgi.url_schemeZ HTTP_HOST)r,r)r*r4)rrrrrr)\s 



r)c
CsR|jd
d�dkrdS|jd�
}
|
dk rNyt
dt|
�
�Sttfk rL


YnXdS)a
Returns the content length from the WSGI environment as integer. If it's not available or chunked transfer encoding is used, ``None`` is returned. .. versionadded:: 0.9 :param environ: the WSGI environ to fetch the content length from. ZHTTP_TRANSFER_ENCODINGr#�chunkedN�CONTENT_LENGTHr
)r*�maxr/r1r0)r�content_lengthrrr�get_content_lengthxs 






r9T)r� safe_fallbackrcCs\tj
tjt|d
�}t|�
}|jd�
r,|S|dkrD|
r@tj�S|Stj
tjtt||��S)a Returns the input stream from the WSGI environment and wraps it in the most sensible way possible. The stream returned is not the raw WSGI stream in most cases but one that is safe to read from without taking into account the content length. If content length is not set, the stream will be empty for safety reasons. If the WSGI server supports chunked or infinite streams, it should set the ``wsgi.input_terminated`` value in the WSGI environ to indicate that. .. versionadded:: 0.9 :param environ: the WSGI environ to fetch the stream from. :param safe_fallback: use an empty stream as a safe fallback when the content length is not set. Disabling this allows infinite streams, which can be a denial-of-service risk. z wsgi.inputzwsgi.input_terminatedN) �
t�cast�IO�bytesr9r*�io�BytesIO� LimitedStream)rr:�streamr8rrr�get_input_stream�s


rCc
Cs|jd
d�j
d�
}
t|
dd�S)a
Returns the ``QUERY_STRING`` from the WSGI environment. This also takes care of the WSGI decoding dance. The string returned will be restricted to ASCII characters. :param environ: WSGI environment to get the query string from. .. versionadded:: 0.9 r'r#r(z:&%=+$!*'(),)
�safe)r*r+r)r�qsrrr�get_query_string�s rF�utf-8�replace)r�charset�errorsrcCs"|jd
d�j
d�
}t||
|dd�S)a[
Return the ``PATH_INFO`` from the WSGI environment and decode it unless ``charset`` is ``None``. :param environ: WSGI environment to get the path from. :param charset: The charset for the path info, or ``None`` if no decoding should be performed. :param errors: The decoding error handling. .. versionadded:: 0.9 r%r#r(T)
�allow_none_charset)r*r+r)rrIrJr&rrr� get_path_info�s 
rLcCs"|jd
d�j
d�
}t||
|dd�S)a]
Return the ``SCRIPT_NAME`` from the WSGI environment and decode it unless `charset` is set to ``None``. :param environ: WSGI environment to get the path from. :param charset: The charset for the path, or ``None`` if no decoding should be performed. :param errors: The decoding error handling. .. versionadded:: 0.9 r"r#r(T)
rK)r*r+r)rrIrJr&rrr�get_script_name�s 
rMcCs�|jd
�
}|sdS|jdd�}|}|j
d�
}||krL|dt|�
t|�
7}d|krtd|d
<|||d<|jd�
}n4|jdd�\}}d|��|d
<|||d<|jd�
}t||
|dd �S) a�Removes and returns the next segment of `PATH_INFO`, pushing it onto `SCRIPT_NAME`. Returns `None` if there is nothing left on `PATH_INFO`. If the `charset` is set to `None` bytes are returned. If there are empty segments (``'/foo//bar``) these are ignored but properly pushed to the `SCRIPT_NAME`: >>> env = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/a/b'} >>> pop_path_info(env) 'a' >>> env['SCRIPT_NAME'] '/foo/a' >>> pop_path_info(env) 'b' >>> env['SCRIPT_NAME'] '/foo/a/b' .. versionadded:: 0.5 .. versionchanged:: 0.9 The path is now decoded and a charset and encoding parameter can be provided. :param environ: the WSGI environment that is modified. :param charset: The ``encoding`` parameter passed to :func:`bytes.decode`. :param errors: The ``errors`` paramater passed to :func:`bytes.decode`. r%Nr"r#�
/r(rT)
rK)r*�lstrip�lenr+�splitr)rrIrJr&�script_nameZold_path�rvZsegmentrrr� pop_path_info�s"!










rTcCs<|jd
d�j
d�
jdd�}|r8t|djd�
|
|dd�Sd S) a'Returns the next segment on the `PATH_INFO` or `None` if there is none. Works like :func:`pop_path_info` without modifying the environment: >>> env = {'SCRIPT_NAME': '/foo', 'PATH_INFO': '/a/b'} >>> peek_path_info(env) 'a' >>> peek_path_info(env) 'a' If the `charset` is set to `None` bytes are returned. .. versionadded:: 0.5 .. versionchanged:: 0.9 The path is now decoded and a charset and encoding parameter can be provided. :param environ: the WSGI environment that is checked. r%r#rNrr
r(T)
rKN)r*rOrQrr+)rrIrJ�segmentsrrr�peek_path_info
s 


rV�werkzeug.url_quote)�environ_or_baseurl�path_or_urlrIrJ�collapse_http_schemesrcCs�tttd
�dd�}t
|
||�}t|t�r4t|dd�}t
|||�}t|�
dd�\}} } tt||��
dd�\}}} ||| �} |||�}|r�x2||fD]}|dkr�dSq�Wn|dko�||ks�dS| |kr�dS| jd �
} | j| �
s�dSd | t | �
d�j d �
��S) a%Extracts the path info from the given URL (or WSGI environment) and path. The path info returned is a string. The URLs might also be IRIs. If the path info could not be determined, `None` is returned. Some examples: >>> extract_path_info('http://example.com/app', '/app/hello') '/hello' >>> extract_path_info('http://example.com/app', ... 'https://example.com/app/hello') '/hello' >>> extract_path_info('http://example.com/app', ... 'https://example.com/app/hello', ... collapse_http_schemes=False) is None True Instead of providing a base URL you can also pass a WSGI environment. :param environ_or_baseurl: a WSGI environment dict, a base URL or base IRI. This is the root of the application. :param path_or_url: an absolute path from the server root, a relative path (in which case it's the path info) or a full URL. :param charset: the charset for byte data in URLs :param errors: the error handling on decode :param collapse_http_schemes: if set to `False` the algorithm does not assume that http and https on the same server point to the same resource. .. versionchanged:: 0.15 The ``errors`` parameter defaults to leaving invalid bytes quoted instead of replacing them. .. versionadded:: 0.6 )r �netlocrcSsx|
jd
d�d jdd�}t
|�
dkrR|\}
}|dkr<|dksL|dkr^|dkr^d}n|d }
d}|dk rt|
d|��7}
|
S)N�
@r�
:r�http�80�httpsZ443r
�����)rQrP)r r[r.r3rrr�_normalize_netlocl
s





z,extract_path_info.._normalize_netlocT)
rN�r^r`rN)r^r`)r^r`)�strr� isinstance�dictr-rr �rstrip� startswithrPrO)rXrYrIrJrZrbr&Zbase_iriZbase_schemeZbase_netloc� base_pathZ cur_schemeZ cur_netlocZcur_pathr rrr�extract_path_info>
s*.












rjc @s~eZ
dZd
Zd ejeejejej gdfejej gdffdd�dd�Z dd�
dd�Zed�
d d �Zdd�
dd�Z dS)�ClosingIteratoraAThe WSGI specification requires that all middlewares and gateways respect the `close` callback of the iterable returned by the application. Because it is useful to add another close action to a returned iterable and adding a custom iterable is a boring task this class can be used for that:: return ClosingIterator(app(environ, start_response), [cleanup_session, cleanup_locals]) If there is just one close function it can be passed instead of the list. A closing iterator is not needed if the application uses response objects and finishes the processing if the response is started:: try: return response(environ, start_response) finally: cleanup_session() cleanup_locals() N)�iterable� callbacksrcCsrt|
�
}t
jt
jgtftt|��|_|dkr4g}nt|�
rD|g
}nt |�
}t |
d
d�}|rh|jd|�
||_dS)N�closer
) �iterr;r<�Callabler>r�next�_next�callable�list�getattr�insert� _callbacks)�selfrlrm�iteratorZiterable_closerrr�__init__�
s








zClosingIterator.__init__)
rc


Cs|S)
Nr)
rxrrr�__iter__�
s
zClosingIterator.__iter__c


Cs|j�S)
N)
rr)
rxrrr�__next__�
s
zClosingIterator.__next__c
Csx|jD] }
|
�
qWdS)
N)
rw)rx�callbackrrrrn�
s

zClosingIterator.close)
N)�__name__� __module__�__qualname__�__doc__r;�Iterabler>�Optional�Unionrprzr{r|rnrrrrrk�
s6
rk� )r�file�buffer_sizercCs|jd
t
�|
|�S)a�Wraps a file. This uses the WSGI server's file wrapper if available or otherwise the generic :class:`FileWrapper`. .. versionadded:: 0.5 If the file wrapper from the WSGI server is used it's important to not iterate over it from inside the application but to pass it through unchanged. If you want to pass out a file wrapper inside a response object you have to set :attr:`Response.direct_passthrough` to `True`. More information about file wrappers are available in :pep:`333`. :param file: a :class:`file`-like object with a :meth:`~file.read` method. :param buffer_size: number of bytes for one iteration. zwsgi.file_wrapper)r*�FileWrapper)rr�r�rrr� wrap_file�
s
r�c@s�eZ
dZd
Zdejeedd�dd�Zdd�
dd �Z e d�
d d�Zejdd�d d�Z ejed�
dd�Zdd�
dd�Zed�
dd�ZdS)r�a\This class can be used to convert a :class:`file`-like object into an iterable. It yields `buffer_size` blocks until the file is fully read. You should not use this class directly but rather use the :func:`wrap_file` function that uses the WSGI server's file wrapper support if it's available. .. versionadded:: 0.5 If you're using this object together with a :class:`Response` you have to use the `direct_passthrough` mode. :param file: a :class:`file`-like object with a :meth:`~file.read` method. :param buffer_size: number of bytes for one iteration. � N)r�r�rcCs|
|_||_
dS)
N)r�r�)rxr�r�rrrrz�
s

zFileWrapper.__init__)
rc

Cst|j
d
�r|j
j�
dS)Nrn)�hasattrr�rn)
rxrrrrns

zFileWrapper.closec

Cs*t|j
d
�r|j
j�St|j
d�r&dSdS)N�seekable�seekTF)r�r�r�)
rxrrrr�s




zFileWrapper.seekable)�argsrc
Gst|j
d
�r|j
j|
�
dS)Nr�)r�r�r�)rxr�rrrr� s

zFileWrapper.seekc

Cst|j
d
�r|j
j�SdS)N�tell)r�r�r�)
rxrrrr�s


zFileWrapper.tellc


Cs|S)
Nr)
rxrrrr{s
zFileWrapper.__iter__c
Cs |jj
|j�
}
|
r|
St��
dS)
N)r��readr�� StopIteration)rx�datarrrr|s



zFileWrapper.__next__)
r�)r~rr�r�r;r=r>r/rzrn�boolr�ZAnyr�r�r�r{r|rrrrr��
sr�c@s�eZ
dZd
Zdejejeejefe ej e d�dd�Zdd�
dd �Zed�
d d�Z ejej ee fd�
dd �Zed�
dd�Zed�
dd�Zdd�
dd�ZdS)� _RangeWrapperasThis class can be used to convert an iterable object into an iterable that will only yield a piece of the underlying content. It yields blocks until the underlying stream range is fully read. The yielded blocks will have a size that can't exceed the original iterator defined block size, but that can be smaller. If you're using this object together with a :class:`Response` you have to use the `direct_passthrough` mode. :param iterable: an iterable object with a :meth:`__next__` method. :param start_byte: byte from which read will start. :param byte_range: how many bytes to read. r
N)rl� start_byte� byte_rangecCsRt|
�
|_
||_||_d|_|dk r.|||_d
|_t|
d�oD|
j�|_d|_dS)Nr
r�F) rorlr�r��end_byte�read_lengthr�r��end_reached)rxrlr�r�rrrrz1s



z_RangeWrapper.__init__)
rc


Cs|S)
Nr)
rxrrrr{Es
z_RangeWrapper.__iter__c
CsBy t|j
�
}
|jt|
�
7_|
Stk r<


d
|_�YnXdS)NT)rqrlr�rPr�r�)rx�chunkrrr�_next_chunkHs






z_RangeWrapper._next_chunkc
Cspd}
|jr,|j
j|j�

|j
j�|_|j}nr=r/r�rzr{r��Tupler�rrr|rnrrrrr� s
0 r�)rB�limitr�rccs�t|t
ttf�rtd
�
�
t|d�s>x|D]}|r(|V
q(WdStjtjt
|�}t|t �r||
dk r|tjtjt
t ||
��}|j }x||�
}|s�P|V
q�WdS)z-Helper for the line and chunk iter functions.zBPassed a string or byte object instead of true iterator or stream.r�N)rer>� bytearrayrdr0r�r;r<r=rAr�)rBr�r��item�_readrrr�_make_chunk_iterys"














r�� i)rBr�r�� cap_at_bufferrc#s�t||
�
��t
�d
�}|sdSt|�
}tjt|d
�
��tjt|d�
�}tjt|d�
�}tjt|d�
��tjtjtt|f
����tjtd�
��
���fdd�}�} x@|�D]6} | |kr�| d d�|kr�| | 7} �} | r�| V
| } q�W| r�| V
dS)a�Safely iterates line-based over an input stream. If the input stream is not a :class:`LimitedStream` the `limit` parameter is mandatory. This uses the stream's :meth:`~file.read` method internally as opposite to the :meth:`~file.readline` method that is unsafe and can only be used in violation of the WSGI specification. The same problem applies to the `__iter__` function of the input stream which calls :meth:`~file.readline` without arguments. If you need line-by-line processing it's strongly recommended to iterate over the input stream using this helper function. .. versionchanged:: 0.8 This function now ensures that the limit was reached. .. versionadded:: 0.9 added support for iterators as input stream. .. versionadded:: 0.11.10 added support for the `cap_at_buffer` parameter. :param stream: the stream or iterate to iterate over. :param limit: the limit in bytes for the stream. (Usually content length. Not necessary if the `stream` is a :class:`LimitedStream`. :param buffer_size: The optional buffer size. :param cap_at_buffer: if this is set chunks are split if they are longer than the buffer size. Internally this is implemented that the buffer size might be exhausted by a factor of two however. r#N�
�
z )
rc3s��j}g}
x�t
�d
�}|sPg}d}x�tjtjtt|
|jd�
��D]�}|j|�

|t |�
7}|r�|dd��kr�||�
V
g}qD�rD|�
krD||�
}x*t |�
�
kr�|d�
�V
|�
d�}q�W|g
}qDW|}
qW|
r�||
�
V
dS)Nr#r
Trra) �joinrqr;r<�Iteratorr>r� splitlines�appendrP)�_join�buffer�new_data�new_buf�buf_sizer�rS)�_iterr�r��crlf�emptyrr�_iter_basic_lines�s0






















z)make_line_iter.._iter_basic_linesrra)r�rqrr;r<r>r�r)rBr�r�r�� first_item�
s�cr�lfr��previousr�r)r�r�r�r�r�r�make_line_iter�s*%





 








r�)rB� separatorr�r�r�rccsn
t|||�}t
|d
�}|sdStjtjtt|f
|��}t|t�rlt |
�
}
t jdt j|
�
�d��
j }dj}n(t|
�
}
t jdt j|
�
d�
j }d
j}g} x�t
|d
�} | s�P|| �
}g}d} x�t| |�D]�}||
kr�||�
V
g}d} q�| t|�
7} |j|�

|r�| |kr�||�
}x.t|�
|k�
r>|d|�V
||d�}�
qW|g
}t|�
} q�W|} q�W| �
rj|| �
V
dS) aWorks like :func:`make_line_iter` but accepts a separator which divides chunks. If you want newline based processing you should use :func:`make_line_iter` instead as it supports arbitrary newline markers. .. versionadded:: 0.8 .. versionadded:: 0.9 added support for iterators as input stream. .. versionadded:: 0.11.10 added support for the `cap_at_buffer` parameter. :param stream: the stream or iterate to iterate over. :param separator: the separator that divides chunks. :param limit: the limit in bytes for the stream. (Usually content length. Not necessary if the `stream` is otherwise already limited). :param buffer_size: The optional buffer size. :param cap_at_buffer: if this is set chunks are split if they are longer than the buffer size. Internally this is implemented that the buffer size might be exhausted by a factor of two however. �N�
(�
)r#�
(�
)r
)r�rqr;r<r�r>rrerdr�re�compile�escaperQr�rrPr�)rBr�r�r�r�r�r��_splitr�r�r��chunksr�r�r�rSrrr�make_chunk_iter�sJ




























r�c@s�eZ
dZd
Zejeedd�dd�Zdd�
dd�Z e ed�
d d ��
Zed�
dd�Z ed�
d d�Zd"edd�dd�Zd#ejeed�dd�Zd$ejeed�dd�Zd%ejeejed�dd�Zed�
dd�Zed�
dd�Zed�
dd �ZdS)&rAa�Wraps a stream so that it doesn't read more than n bytes. If the stream is exhausted and the caller tries to get more bytes from it :func:`on_exhausted` is called which by default returns an empty string. The return value of that function is forwarded to the reader function. So if it returns an empty string :meth:`read` will return an empty string as well. The limit however must never be higher than what the stream can output. Otherwise :meth:`readlines` will try to read past the limit. .. admonition:: Note on WSGI compliance calls to :meth:`readline` and :meth:`readlines` are not WSGI compliant because it passes a size argument to the readline methods. Unfortunately the WSGI PEP is not safely implementable without a size argument to :meth:`readline` because there is no EOF marker in the stream. As a result of that the use of :meth:`readline` is discouraged. For the same reason iterating over the :class:`LimitedStream` is not portable. It internally calls :meth:`readline`. We strongly suggest using :meth:`read` only or using the :func:`make_line_iter` which safely iterates line-based over a WSGI input stream. :param stream: the stream to wrap. :param limit: the limit for the stream, must not be longer than what the string can provide if the stream does not end with `EOF` (like `wsgi.input`) N)rBr�rcCs |
j|_
|
j|_d
|_||_dS)Nr
)r�r��readline� _readline�_posr�)rxrBr�rrrrz^s



zLimitedStream.__init__)
rc


Cs|S)
Nr)
rxrrrr{ds
zLimitedStream.__iter__c

Cs|j|j
kS)
z4If the stream is exhausted this attribute is `True`.)r�r�)
rxrrr�is_exhaustedgszLimitedStream.is_exhaustedc

Cs |jd
�
S)z�This is called when the stream tries to read past the limit. The return value of this function is returned from the reading function. r
)
r�)
rxrrr�on_exhaustedlszLimitedStream.on_exhaustedc
Csd
dlm
}

|
��
dS)a
What should happen if a disconnect is detected? The return value of this function is returned from read functions in case the client went away. By default a :exc:`~werkzeug.exceptions.ClientDisconnected` exception is raised. r)
�ClientDisconnectedN)� exceptionsr�)rxr�rrr� on_disconnectuszLimitedStream.on_disconnecti�@)� chunk_sizercCs>|j|j
}|
}x(|d
kr8t||�}|j|�

||8}qWdS)a
Exhaust the stream. This consumes all the data left until the limit is reached. :param chunk_size: the size for a chunk. It will read the chunk until the stream is exhausted and throw away the results. r
N)r�r��minr�)rxr��to_readr�rrr�exhausts




zLimitedStream.exhaust)�sizercCs�|j|j
kr|j�S|
d
ks$|
dkr*|j
}
t|j
|j|
�}y|j|�
}Wnttfk rf


|j�SX|r�t|�
|kr�|j�S|jt|�
7_|S)zyRead `size` bytes or if size is not provided everything is read. :param size: the number of bytes read. Nrra) r�r�r�r�r��OSErrorr1r�rP)rxr�r�r�rrrr��s











zLimitedStream.readcCs�|j|j
kr|j�S|
d
kr*|j
|j}
nt|
|j
|j�}
y|j|
�
}Wnttfk rf


|j�SX|
rz|rz|j�S|jt|�
7_|S)zReads one line from the stream.N) r�r�r�r�r�r1r�r�rP)rxr��linerrrr��s










zLimitedStream.readlinecCst|j}g}|
d
k r$t
|j||
�}n|j}xD|
d
k rB|
||j8}
|j|krNP|j|j|
�
�

|
d
k r,|j}q,W|S)z�Reads a file into a list of strings. It calls :meth:`readline` until the file is read to the end. It does support the optional `size` argument if the underlying stream supports it for `readline`. N)r�r�r�r�r�)rxr�Zlast_pos�result�endrrr� readlines�s











zLimitedStream.readlinesc


Cs|jS)
zKReturns the position of the stream. .. versionadded:: 0.9 )
r�)
rxrrrr��szLimitedStream.tellc

Cs|j�}
|
st
��
|
S)
N)r�r�)rxr�rrrr|�s



zLimitedStream.__next__c


Csd
S)NTr)
rxrrr�readable�s
zLimitedStream.readable�
)
r�)
N)
N)
N)r~rr�r�r;r=r>r/rzr{�propertyr�r�r�r�r�r�r�r�ZListr�r�r|r�rrrrrA<s 
  rA).r)FFFN)
N)
T)rGrH)rGrH)rGrH)rGrH)rGrWT)
r��()Nr�F�()Nr�F)rCrFrLrMrTrVr�rjrkr�r�r�r�r�r�r��IOBaserArrrr�
s|



















!
$

$


9



\6
4Z




&
Z

(
G